mcp-sqlite-memory-bank 1.4.2__tar.gz → 1.4.3__tar.gz

{mcp_sqlite_memory_bank-1.4.2/src/mcp_sqlite_memory_bank.egg-info → mcp_sqlite_memory_bank-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp_sqlite_memory_bank
-Version: 1.4.2
+Version: 1.4.3
 Summary: A dynamic, agent/LLM-friendly SQLite memory bank for MCP servers with semantic search capabilities.
 Author-email: Robert Meisner <robert@catchit.pl>
 License-Expression: MIT

{mcp_sqlite_memory_bank-1.4.2 → mcp_sqlite_memory_bank-1.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp_sqlite_memory_bank"
-version = "1.4.2"
+version = "1.4.3"
 description = "A dynamic, agent/LLM-friendly SQLite memory bank for MCP servers with semantic search capabilities."
 authors = [
     { name="Robert Meisner", email="robert@catchit.pl" }

{mcp_sqlite_memory_bank-1.4.2 → mcp_sqlite_memory_bank-1.4.3}/src/mcp_sqlite_memory_bank/database.py

@@ -27,7 +27,6 @@ from .types import (
     SemanticSearchResponse,
     RelatedContentResponse,
     HybridSearchResponse,
-    EmbeddingStatsResponse,
 )
 from .semantic import get_semantic_engine, is_semantic_search_available
 
@@ -932,11 +931,28 @@ class SQLiteMemoryDatabase:
                 raise e
             raise DatabaseError(f"Hybrid search failed: {str(e)}")
 
-    def get_embedding_stats(self, table_name: str, embedding_column: str = "embedding") -> EmbeddingStatsResponse:
+    def get_embedding_stats(self, table_name: str, embedding_column: str = "embedding") -> ToolResponse:
         """Get statistics about embeddings in a table."""
         try:
             table = self._ensure_table_exists(table_name)
 
+            # Check if embedding column exists
+            if embedding_column not in [col.name for col in table.columns]:
+                # Return 0% coverage when column doesn't exist (for compatibility with tests)
+                total_count = 0
+                with self.get_connection() as conn:
+                    total_count = conn.execute(select(text("COUNT(*)")).select_from(table)).scalar() or 0
+                
+                return {
+                    "success": True,
+                    "table_name": table_name,
+                    "total_rows": total_count,
+                    "embedded_rows": 0,
+                    "coverage_percent": 0.0,
+                    "embedding_dimensions": None,
+                    "embedding_column": embedding_column,
+                }
+
             with self.get_connection() as conn:
                 # Count total rows
                 total_count = conn.execute(select(text("COUNT(*)")).select_from(table)).scalar() or 0

{mcp_sqlite_memory_bank-1.4.2 → mcp_sqlite_memory_bank-1.4.3}/src/mcp_sqlite_memory_bank/server.py

@@ -715,23 +715,29 @@ def auto_semantic_search(
     """
     try:
         db = get_database(DB_PATH)
-        auto_embedded_tables = []
+        auto_embedded_tables: List[str] = []
         
         # Get tables to search
+        search_tables: List[str]
         if tables:
             search_tables = tables
         else:
             tables_result = db.list_tables()
             if not tables_result.get("success"):
                 return cast(ToolResponse, tables_result)
-            search_tables = tables_result.get("tables", [])
+            all_tables = tables_result.get("tables", [])
+            if isinstance(all_tables, list):
+                search_tables = all_tables
+            else:
+                search_tables = []
         
         # Auto-embed text columns in tables that don't have embeddings
         for table_name in search_tables:
             try:
                 # Check if table has embeddings
                 stats_result = db.get_embedding_stats(table_name, "embedding")
-                if stats_result.get("success") and stats_result.get("coverage_percent", 0) > 0:
+                coverage_percent = stats_result.get("coverage_percent", 0)
+                if stats_result.get("success") and isinstance(coverage_percent, (int, float)) and coverage_percent > 0:
                     continue  # Table already has embeddings
                 
                 # Get table schema to find text columns
@@ -741,9 +747,11 @@ def auto_semantic_search(
                 
                 # Find text columns
                 text_columns = []
-                for col in schema_result.get("columns", []):
-                    if "TEXT" in col.get("type", "").upper():
-                        text_columns.append(col["name"])
+                columns = schema_result.get("columns", [])
+                if isinstance(columns, list):
+                    for col in columns:
+                        if isinstance(col, dict) and "TEXT" in col.get("type", "").upper():
+                            text_columns.append(col["name"])
                 
                 # Auto-embed text columns
                 if text_columns:
@@ -822,12 +830,54 @@ def auto_smart_search(
         - Perfect for agents - ultimate search tool that just works!
     """
     try:
-        # First try auto semantic search to ensure embeddings exist
-        auto_semantic_result = auto_semantic_search(query, tables, 0.3, limit, model_name)
-        auto_embedded_tables = []
+        db = get_database(DB_PATH)
+        auto_embedded_tables: List[str] = []
         
-        if auto_semantic_result.get("success"):
-            auto_embedded_tables = auto_semantic_result.get("auto_embedded_tables", [])
+        # Get tables to search
+        search_tables: List[str]
+        if tables:
+            search_tables = tables
+        else:
+            tables_result = db.list_tables()
+            if not tables_result.get("success"):
+                return cast(ToolResponse, tables_result)
+            all_tables = tables_result.get("tables", [])
+            if isinstance(all_tables, list):
+                search_tables = all_tables
+            else:
+                search_tables = []
+        
+        # Auto-embed text columns in tables that don't have embeddings
+        for table_name in search_tables:
+            try:
+                # Check if table has embeddings
+                stats_result = db.get_embedding_stats(table_name, "embedding")
+                coverage_percent = stats_result.get("coverage_percent", 0)
+                if stats_result.get("success") and isinstance(coverage_percent, (int, float)) and coverage_percent > 0:
+                    continue  # Table already has embeddings
+                
+                # Get table schema to find text columns
+                schema_result = db.describe_table(table_name)
+                if not schema_result.get("success"):
+                    continue
+                
+                # Find text columns
+                text_columns = []
+                columns = schema_result.get("columns", [])
+                if isinstance(columns, list):
+                    for col in columns:
+                        if isinstance(col, dict) and "TEXT" in col.get("type", "").upper():
+                            text_columns.append(col["name"])
+                
+                # Auto-embed text columns
+                if text_columns:
+                    embed_result = db.generate_embeddings(table_name, text_columns, "embedding", model_name)
+                    if embed_result.get("success"):
+                        auto_embedded_tables.append(table_name)
+                        
+            except Exception:
+                # If auto-embedding fails, continue without it
+                continue
         
         # Now perform hybrid search
         db = get_database(DB_PATH)
@@ -836,13 +886,16 @@ def auto_smart_search(
         )
         
         # Add auto-embedding info to result
-        if isinstance(hybrid_result, dict):
-            hybrid_result["search_type"] = "auto_hybrid"
-            hybrid_result["auto_embedded_tables"] = auto_embedded_tables
+        if isinstance(hybrid_result, dict) and hybrid_result.get("success"):
+            # Convert to mutable dict to add extra fields
+            final_result = dict(hybrid_result)
+            final_result["search_type"] = "auto_hybrid"
+            final_result["auto_embedded_tables"] = auto_embedded_tables
             if auto_embedded_tables:
-                hybrid_result["auto_embedding_note"] = f"Automatically generated embeddings for {len(auto_embedded_tables)} table(s)"
-        
-        return cast(ToolResponse, hybrid_result)
+                final_result["auto_embedding_note"] = f"Automatically generated embeddings for {len(auto_embedded_tables)} table(s)"
+            return cast(ToolResponse, final_result)
+        else:
+            return cast(ToolResponse, hybrid_result)
         
     except Exception as e:
         return cast(ToolResponse, {
@@ -853,6 +906,36 @@ def auto_smart_search(
         })
 
 
+@mcp.tool
+@catch_errors 
+def embedding_stats(table_name: str, embedding_column: str = "embedding") -> ToolResponse:
+    """
+    Get statistics about semantic search readiness for a table.
+
+    Check which content has embeddings and can be searched semantically.
+
+    Args:
+        table_name (str): Table to analyze
+        embedding_column (str): Embedding column to check (default: "embedding")
+
+    Returns:
+        ToolResponse: On success: {"success": True, "coverage_percent": float, "total_rows": int}
+                     On error: {"success": False, "error": str, "category": str, "details": dict}
+
+    Examples:
+        >>> embedding_stats("technical_decisions")
+        {"success": True, "total_rows": 25, "embedded_rows": 25, "coverage_percent": 100.0,
+         "embedding_dimensions": 384}
+
+    FastMCP Tool Info:
+        - Shows how much content is ready for semantic search
+        - Helps identify tables that need embedding generation  
+        - Provides embedding dimension info for debugging
+        - Useful for monitoring semantic search capabilities
+    """
+    return cast(ToolResponse, get_database(DB_PATH).get_embedding_stats(table_name, embedding_column))
+
+
 # --- Enhanced Tool Discovery and Categorization ---
 
 

{mcp_sqlite_memory_bank-1.4.2 → mcp_sqlite_memory_bank-1.4.3}/src/mcp_sqlite_memory_bank/types.py

@@ -180,7 +180,7 @@ class ExploreTablesResponse(SuccessResponse):
 
 
 # Semantic Search Response Types
-class SemanticSearchResponse(TypedDict):
+class SemanticSearchResponse(TypedDict, total=False):
     """Response type for semantic search operations."""
 
     success: bool
@@ -190,6 +190,8 @@ class SemanticSearchResponse(TypedDict):
     total_results: int
     model: str
     similarity_threshold: float
+    auto_embedded_tables: List[str]  # Tables that had embeddings auto-generated
+    auto_embedding_note: str  # Message about auto-embedding
 
 
 class RelatedContentResponse(TypedDict, total=False):

{mcp_sqlite_memory_bank-1.4.2 → mcp_sqlite_memory_bank-1.4.3/src/mcp_sqlite_memory_bank.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp_sqlite_memory_bank
-Version: 1.4.2
+Version: 1.4.3
 Summary: A dynamic, agent/LLM-friendly SQLite memory bank for MCP servers with semantic search capabilities.
 Author-email: Robert Meisner <robert@catchit.pl>
 License-Expression: MIT