mcp-sqlite-memory-bank 1.6.0__py3-none-any.whl → 1.6.2__py3-none-any.whl

mcp_sqlite_memory_bank/server.py

@@ -43,14 +43,25 @@ Each tool is designed for explicit, discoverable use by LLMs and agents:
 Author: Robert Meisner
 """
 
+from .tools.discovery import (
+    intelligent_discovery as intelligent_discovery_impl,
+    discovery_templates as discovery_templates_impl,
+    discover_relationships as discover_relationships_impl,
+)
+from .tools.search import (
+    search_content as search_content_impl,
+    explore_tables as explore_tables_impl,
+    add_embeddings as add_embeddings_impl,
+    auto_semantic_search as auto_semantic_search_impl,
+    auto_smart_search as auto_smart_search_impl,
+    embedding_stats as embedding_stats_impl,
+)
 import os
-import re
 import logging
 from typing import Dict, Optional, List, cast, Any
 from fastmcp import FastMCP
 
 from .database import get_database
-from .semantic import is_semantic_search_available
 from .types import (
     ToolResponse,
     CreateTableResponse,
@@ -124,9 +135,7 @@ def create_table(table_name: str, columns: List[Dict[str, str]]) -> ToolResponse
         - Creates table if it doesn't exist (idempotent)
         - Raises appropriate errors for invalid input
     """
-    return cast(
-        CreateTableResponse, get_database(DB_PATH).create_table(table_name, columns)
-    )
+    return cast(CreateTableResponse, get_database(DB_PATH).create_table(table_name, columns))
 
 
 @mcp.tool
@@ -238,9 +247,7 @@ def rename_table(old_name: str, new_name: str) -> ToolResponse:
         - Validates both old and new table names
         - Confirms old table exists and new name doesn't conflict
     """
-    return cast(
-        RenameTableResponse, get_database(DB_PATH).rename_table(old_name, new_name)
-    )
+    return cast(RenameTableResponse, get_database(DB_PATH).rename_table(old_name, new_name))
 
 
 @mcp.tool
@@ -271,9 +278,7 @@ def create_row(table_name: str, data: Dict[str, Any]) -> ToolResponse:
 
 @mcp.tool
 @catch_errors
-def upsert_memory(
-    table_name: str, data: Dict[str, Any], match_columns: List[str]
-) -> ToolResponse:
+def upsert_memory(table_name: str, data: Dict[str, Any], match_columns: List[str]) -> ToolResponse:
     """
     🔄 **SMART MEMORY UPSERT** - Prevent duplicates and maintain data consistency!
 
@@ -358,16 +363,12 @@ def update_rows(
         - Parameterizes all queries for safety
         - Where clause is optional (omitting it updates all rows!)
     """
-    return cast(
-        UpdateRowsResponse, get_database(DB_PATH).update_rows(table_name, data, where)
-    )
+    return cast(UpdateRowsResponse, get_database(DB_PATH).update_rows(table_name, data, where))
 
 
 @mcp.tool
 @catch_errors
-def delete_rows(
-    table_name: str, where: Optional[Dict[str, Any]] = None
-) -> ToolResponse:
+def delete_rows(table_name: str, where: Optional[Dict[str, Any]] = None) -> ToolResponse:
     """
     Delete rows from any table in the SQLite Memory Bank for Copilot/AI agents, matching the WHERE clause.
 
@@ -389,9 +390,7 @@ def delete_rows(
         - Parameterizes all queries for safety
         - Where clause is optional (omitting it deletes all rows!)
     """
-    return cast(
-        DeleteRowsResponse, get_database(DB_PATH).delete_rows(table_name, where)
-    )
+    return cast(DeleteRowsResponse, get_database(DB_PATH).delete_rows(table_name, where))
 
 
 @mcp.tool
@@ -454,21 +453,8 @@ def list_all_columns() -> ToolResponse:
 
 
 # Import the implementation functions from tools modules
-from .tools.search import (
-    search_content as search_content_impl,
-    explore_tables as explore_tables_impl,
-    add_embeddings as add_embeddings_impl,
-    auto_semantic_search as auto_semantic_search_impl,
-    auto_smart_search as auto_smart_search_impl,
-    embedding_stats as embedding_stats_impl,
-)
 
 # Import the implementation functions from discovery module
-from .tools.discovery import (
-    intelligent_discovery as intelligent_discovery_impl,
-    discovery_templates as discovery_templates_impl,
-    discover_relationships as discover_relationships_impl,
-)
 
 # --- MCP Tool Definitions (Required in main server.py for FastMCP) ---
 
@@ -635,9 +621,7 @@ def auto_semantic_search(
         - Supports fuzzy matching and concept discovery
         - Perfect for agents - just search and it works!
     """
-    return auto_semantic_search_impl(
-        query, tables, similarity_threshold, limit, model_name
-    )
+    return auto_semantic_search_impl(query, tables, similarity_threshold, limit, model_name)
 
 
 @mcp.tool
@@ -684,9 +668,7 @@ def auto_smart_search(
         - Optimal for both exploratory and precise searches
         - Perfect for agents - ultimate search tool that just works!
     """
-    return auto_smart_search_impl(
-        query, tables, semantic_weight, text_weight, limit, model_name
-    )
+    return auto_smart_search_impl(query, tables, semantic_weight, text_weight, limit, model_name)
 
 
 @mcp.tool
@@ -820,9 +802,7 @@ def smart_search(
         - Optimal for both exploratory and precise searches
         - Perfect for agents - ultimate search tool that just works!
     """
-    return _smart_search_impl(
-        query, tables, semantic_weight, text_weight, limit, model_name
-    )
+    return _smart_search_impl(query, tables, semantic_weight, text_weight, limit, model_name)
 
 
 @mcp.tool
@@ -864,9 +844,7 @@ def find_related(
         - Can reveal patterns and themes across your knowledge base
         - Enables serendipitous discovery of relevant information
     """
-    return _find_related_impl(
-        table_name, row_id, similarity_threshold, limit, model_name
-    )
+    return _find_related_impl(table_name, row_id, similarity_threshold, limit, model_name)
 
 
 # --- Advanced Discovery Tools for SQLite Memory Bank ---
@@ -1011,9 +989,7 @@ def discover_relationships(
         - **ACTIONABLE INSIGHTS**: Suggests how to leverage discovered relationships
         - **PERFECT FOR EXPLORATION**: Reveals hidden data organization patterns
     """
-    return discover_relationships_impl(
-        table_name, relationship_types, similarity_threshold
-    )
+    return discover_relationships_impl(table_name, relationship_types, similarity_threshold)
 
 
 # Export the FastMCP app for use in other modules and server runners
@@ -1095,15 +1071,11 @@ def main():
     import uvicorn
     import argparse
 
-    parser = argparse.ArgumentParser(
-        description="Run MCP SQLite Memory Bank Server in HTTP mode"
-    )
+    parser = argparse.ArgumentParser(description="Run MCP SQLite Memory Bank Server in HTTP mode")
     parser.add_argument("--host", default="127.0.0.1", help="Host to bind to")
     parser.add_argument("--port", type=int, default=8000, help="Port to bind to")
     parser.add_argument("--db-path", help="Path to SQLite database file")
-    parser.add_argument(
-        "--reload", action="store_true", help="Enable auto-reload for development"
-    )
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload for development")
 
     args = parser.parse_args()
 
@@ -1113,9 +1085,7 @@ def main():
         DB_PATH = args.db_path
         os.environ["DB_PATH"] = args.db_path
 
-    print(
-        f"Starting MCP SQLite Memory Bank server in HTTP mode on {args.host}:{args.port}"
-    )
+    print(f"Starting MCP SQLite Memory Bank server in HTTP mode on {args.host}:{args.port}")
     print(f"Database path: {DB_PATH}")
     print("Available at: http://localhost:8000/docs")
 

mcp_sqlite_memory_bank/tools/analytics.py

@@ -7,8 +7,7 @@ and providing insights for better knowledge organization.
 """
 
 import logging
-from typing import Dict, Optional, List, cast, Any
-from fastmcp import FastMCP
+from typing import cast
 
 from ..database import get_database
 from ..semantic import is_semantic_search_available
@@ -80,19 +79,14 @@ def analyze_memory_patterns() -> ToolResponse:
                 schema_result = db.describe_table(table_name)
                 if schema_result.get("success"):
                     columns = schema_result.get("columns", [])
-                    text_columns = [
-                        col for col in columns if "TEXT" in col.get("type", "").upper()
-                    ]
+                    text_columns = [col for col in columns if "TEXT" in col.get("type", "").upper()]
 
                     analysis["schema_analysis"][table_name] = {
                         "total_columns": len(columns),
                         "text_columns": len(text_columns),
-                        "has_id_column": any(
-                            col.get("name") == "id" for col in columns
-                        ),
+                        "has_id_column": any(col.get("name") == "id" for col in columns),
                         "has_timestamp": any(
-                            "timestamp" in col.get("name", "").lower()
-                            for col in columns
+                            "timestamp" in col.get("name", "").lower() for col in columns
                         ),
                     }
 
@@ -106,9 +100,7 @@ def analyze_memory_patterns() -> ToolResponse:
                                     text_content_lengths.append(len(str(content)))
 
                         if text_content_lengths:
-                            avg_length = sum(text_content_lengths) / len(
-                                text_content_lengths
-                            )
+                            avg_length = sum(text_content_lengths) / len(text_content_lengths)
                             if avg_length > 500:
                                 analysis["text_density"]["high"].append(table_name)
                             elif avg_length > 100:
@@ -126,9 +118,7 @@ def analyze_memory_patterns() -> ToolResponse:
                         elif coverage > 0:
                             analysis["semantic_readiness"]["partial"].append(table_name)
                         else:
-                            analysis["semantic_readiness"]["needs_setup"].append(
-                                table_name
-                            )
+                            analysis["semantic_readiness"]["needs_setup"].append(table_name)
 
             except Exception as e:
                 logging.warning(f"Error analyzing table {table_name}: {e}")
@@ -142,8 +132,7 @@ def analyze_memory_patterns() -> ToolResponse:
             high_value_tables = [
                 t
                 for t in analysis["semantic_readiness"]["needs_setup"]
-                if t
-                in analysis["text_density"]["high"] + analysis["text_density"]["medium"]
+                if t in analysis["text_density"]["high"] + analysis["text_density"]["medium"]
             ]
             if high_value_tables:
                 recommendations.append(
@@ -151,9 +140,7 @@ def analyze_memory_patterns() -> ToolResponse:
                 )
 
         # Content organization recommendations
-        large_tables = [
-            t for t, count in analysis["content_distribution"].items() if count > 50
-        ]
+        large_tables = [t for t, count in analysis["content_distribution"].items() if count > 50]
         if large_tables:
             recommendations.append(
                 f"Large tables detected: {', '.join(large_tables)}. Consider organizing with categories or tags."
@@ -161,9 +148,7 @@ def analyze_memory_patterns() -> ToolResponse:
 
         # Empty or sparse tables
         sparse_tables = [
-            t
-            for t, count in analysis["content_distribution"].items()
-            if count < 5 and count > 0
+            t for t, count in analysis["content_distribution"].items() if count < 5 and count > 0
         ]
         if sparse_tables:
             recommendations.append(
@@ -282,19 +267,14 @@ def get_content_health_score() -> ToolResponse:
                 schema_result = db.describe_table(table_name)
                 if schema_result.get("success"):
                     columns = schema_result.get("columns", [])
-                    text_columns = [
-                        col for col in columns if "TEXT" in col.get("type", "").upper()
-                    ]
+                    text_columns = [col for col in columns if "TEXT" in col.get("type", "").upper()]
 
                     analysis["schema_analysis"][table_name] = {
                         "total_columns": len(columns),
                         "text_columns": len(text_columns),
-                        "has_id_column": any(
-                            col.get("name") == "id" for col in columns
-                        ),
+                        "has_id_column": any(col.get("name") == "id" for col in columns),
                         "has_timestamp": any(
-                            "timestamp" in col.get("name", "").lower()
-                            for col in columns
+                            "timestamp" in col.get("name", "").lower() for col in columns
                         ),
                     }
 
@@ -308,9 +288,7 @@ def get_content_health_score() -> ToolResponse:
                                     text_content_lengths.append(len(str(content)))
 
                         if text_content_lengths:
-                            avg_length = sum(text_content_lengths) / len(
-                                text_content_lengths
-                            )
+                            avg_length = sum(text_content_lengths) / len(text_content_lengths)
                             if avg_length > 500:
                                 analysis["text_density"]["high"].append(table_name)
                             elif avg_length > 100:
@@ -328,9 +306,7 @@ def get_content_health_score() -> ToolResponse:
                         elif coverage > 0:
                             analysis["semantic_readiness"]["partial"].append(table_name)
                         else:
-                            analysis["semantic_readiness"]["needs_setup"].append(
-                                table_name
-                            )
+                            analysis["semantic_readiness"]["needs_setup"].append(table_name)
 
             except Exception as e:
                 logging.warning(f"Error analyzing table {table_name}: {e}")
@@ -362,9 +338,7 @@ def get_content_health_score() -> ToolResponse:
         else:
             metrics["content_volume"] = 10.0
 
-        metrics["content_quality"] = min(
-            10.0, (high_quality_tables / total_tables) * 10 + 3
-        )
+        metrics["content_quality"] = min(10.0, (high_quality_tables / total_tables) * 10 + 3)
 
         # 2. Organization Score (based on schema quality)
         schema_analysis = analysis.get("schema_analysis", {})
@@ -383,32 +357,21 @@ def get_content_health_score() -> ToolResponse:
             organization_factors.append(table_score)
 
         metrics["organization"] = (
-            (sum(organization_factors) / len(organization_factors))
-            if organization_factors
-            else 5.0
+            (sum(organization_factors) / len(organization_factors)) if organization_factors else 5.0
         )
 
         # 3. Semantic Readiness Score
         semantic_ready = len(analysis.get("semantic_readiness", {}).get("ready", []))
-        semantic_partial = len(
-            analysis.get("semantic_readiness", {}).get("partial", [])
-        )
-        semantic_needed = len(
-            analysis.get("semantic_readiness", {}).get("needs_setup", [])
-        )
-
+        semantic_partial = len(analysis.get("semantic_readiness", {}).get("partial", []))
         if not is_semantic_search_available():
             metrics["semantic_readiness"] = 5.0  # Neutral score if not available
             metrics["semantic_note"] = "Semantic search dependencies not available"
         else:
-            semantic_score = (
-                (semantic_ready * 2 + semantic_partial) / (total_tables * 2)
-            ) * 10
+            semantic_score = ((semantic_ready * 2 + semantic_partial) / (total_tables * 2)) * 10
             metrics["semantic_readiness"] = min(10.0, semantic_score)
 
         # 4. Accessibility Score (how easy it is to find and use content)
         medium_density = len(analysis.get("text_density", {}).get("medium", []))
-        low_density = len(analysis.get("text_density", {}).get("low", []))
 
         # Prefer medium density (not too verbose, not too sparse)
         if total_tables == 0:

mcp_sqlite_memory_bank/tools/basic.py

@@ -8,7 +8,7 @@ data operations, and core functionality.
 from typing import Any, Dict, List, Optional, cast
 
 from ..database import get_database
-from ..types import MemoryBankError, DatabaseError, ToolResponse
+from ..types import ToolResponse
 from ..utils import catch_errors
 
 
@@ -20,9 +20,7 @@ def create_table(
     """Create a new table in the SQLite memory bank."""
     from .. import server
 
-    return cast(
-        ToolResponse, get_database(server.DB_PATH).create_table(table_name, columns)
-    )
+    return cast(ToolResponse, get_database(server.DB_PATH).create_table(table_name, columns))
 
 
 @catch_errors
@@ -54,9 +52,7 @@ def rename_table(old_name: str, new_name: str) -> ToolResponse:
     """Rename a table in the SQLite memory bank."""
     from .. import server
 
-    return cast(
-        ToolResponse, get_database(server.DB_PATH).rename_table(old_name, new_name)
-    )
+    return cast(ToolResponse, get_database(server.DB_PATH).rename_table(old_name, new_name))
 
 
 @catch_errors
@@ -90,9 +86,7 @@ def update_rows(
     """Update rows in any table in the SQLite Memory Bank, matching the WHERE clause."""
     from .. import server
 
-    return cast(
-        ToolResponse, get_database(server.DB_PATH).update_rows(table_name, data, where)
-    )
+    return cast(ToolResponse, get_database(server.DB_PATH).update_rows(table_name, data, where))
 
 
 @catch_errors
@@ -103,9 +97,7 @@ def delete_rows(
     """Delete rows from any table in the SQLite Memory Bank, matching the WHERE clause."""
     from .. import server
 
-    return cast(
-        ToolResponse, get_database(server.DB_PATH).delete_rows(table_name, where)
-    )
+    return cast(ToolResponse, get_database(server.DB_PATH).delete_rows(table_name, where))
 
 
 @catch_errors
@@ -133,9 +125,7 @@ def list_all_columns() -> ToolResponse:
 
 
 @catch_errors
-def upsert_memory(
-    table_name: str, data: Dict[str, Any], match_columns: List[str]
-) -> ToolResponse:
+def upsert_memory(table_name: str, data: Dict[str, Any], match_columns: List[str]) -> ToolResponse:
     """
     Smart memory upsert: Update existing records or create new ones based on matching columns.
 
@@ -148,7 +138,8 @@ def upsert_memory(
         match_columns (List[str]): Columns to use for finding existing records
 
     Returns:
-        ToolResponse: {"success": True, "action": "updated"|"created", "id": rowid}
+        ToolResponse: For updates: {"success": True, "action": "updated", "id": rowid, "updated_fields": {...}}
+                     For creates: {"success": True, "action": "created", "id": rowid}
     """
     import os
 
@@ -174,8 +165,21 @@ def upsert_memory(
             # Update the first matching record
             row_id = existing_rows[0].get("id")
             if row_id:
+                # Get the original record to compare changes
+                original_record = existing_rows[0]
+                
                 update_result = db.update_rows(table_name, data, {"id": row_id})
                 if update_result.get("success"):
+                    # Determine which fields were actually updated
+                    updated_fields = {}
+                    for key, new_value in data.items():
+                        original_value = original_record.get(key)
+                        if original_value != new_value:
+                            updated_fields[key] = {
+                                "old": original_value,
+                                "new": new_value
+                            }
+                    
                     return cast(
                         ToolResponse,
                         {
@@ -183,6 +187,7 @@ def upsert_memory(
                             "action": "updated",
                             "id": row_id,
                             "rows_affected": update_result.get("rows_affected", 1),
+                            "updated_fields": updated_fields,
                         },
                     )
                 return cast(ToolResponse, update_result)
@@ -308,9 +313,7 @@ def batch_create_memories(
 
             except Exception as e:
                 failed_count += 1
-                results.append(
-                    {"index": i, "action": "failed", "error": str(e), "success": False}
-                )
+                results.append({"index": i, "action": "failed", "error": str(e), "success": False})
 
         return cast(
             ToolResponse,