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

{mcp_sqlite_memory_bank-1.4.1/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.1
+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.1 → 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.1"
+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.1 → 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
 
@@ -429,7 +428,12 @@ class SQLiteMemoryDatabase:
                             )
 
             # Sort by relevance and limit results
-            results.sort(key=lambda x: x["relevance"], reverse=True)
+            def get_relevance(x: Dict[str, Any]) -> float:
+                rel = x.get("relevance", 0)
+                if isinstance(rel, (int, float)):
+                    return float(rel)
+                return 0.0
+            results.sort(key=get_relevance, reverse=True)
             results = results[:limit]
 
             return {
@@ -453,7 +457,7 @@ class SQLiteMemoryDatabase:
             if pattern:
                 table_names = [name for name in table_names if pattern.replace("%", "") in name]
 
-            exploration = {"tables": [], "total_tables": len(table_names), "total_rows": 0}
+            exploration: Dict[str, Any] = {"tables": [], "total_tables": len(table_names), "total_rows": 0}
 
             with self.get_connection() as conn:
                 for table_name in table_names:
@@ -461,7 +465,7 @@ class SQLiteMemoryDatabase:
 
                     # Build column info and identify text columns
                     columns = []
-                    text_columns = []
+                    text_columns: List[str] = []
 
                     for col in table.columns:
                         col_data = {
@@ -476,7 +480,7 @@ class SQLiteMemoryDatabase:
                         if "TEXT" in str(col.type).upper() or "VARCHAR" in str(col.type).upper():
                             text_columns.append(col.name)
 
-                    table_info = {"name": table_name, "columns": columns, "text_columns": text_columns}
+                    table_info: Dict[str, Any] = {"name": table_name, "columns": columns, "text_columns": text_columns}
 
                     # Add row count if requested
                     if include_row_counts:
@@ -493,11 +497,11 @@ class SQLiteMemoryDatabase:
 
                     # Add content preview for text columns
                     if text_columns:
-                        content_preview = {}
+                        content_preview: Dict[str, List[Any]] = {}
                         for col_name in text_columns[:3]:  # Limit to first 3 text columns
                             col = table.c[col_name]
                             preview_result = conn.execute(select(col).distinct().where(col.isnot(None)).limit(5))
-                            unique_values = [row[0] for row in preview_result.fetchall() if row[0]]
+                            unique_values: List[Any] = [row[0] for row in preview_result.fetchall() if row[0]]
                             if unique_values:
                                 content_preview[col_name] = unique_values
 
@@ -927,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
@@ -1001,6 +1022,9 @@ def get_database(db_path: Optional[str] = None) -> SQLiteMemoryDatabase:
     global _db_instance
 
     actual_path = db_path or os.environ.get("DB_PATH", "./test.db")
+    if actual_path is None:
+        actual_path = "./test.db"
+    
     if _db_instance is None or (db_path and db_path != _db_instance.db_path):
         # Close previous instance if it exists
         if _db_instance is not None:

{mcp_sqlite_memory_bank-1.4.1 → mcp_sqlite_memory_bank-1.4.3}/src/mcp_sqlite_memory_bank/prompts.py

@@ -11,7 +11,7 @@ stored memory content into LLM conversations.
 Author: Robert Meisner
 """
 
-from typing import Optional
+from typing import Optional, Dict, List, Any, cast
 from fastmcp import FastMCP
 from .database import get_database
 import json
@@ -35,7 +35,7 @@ class MemoryBankPrompts:
             
             if table_name:
                 # Analyze specific table
-                result = db.read_rows(table_name, {})
+                result = cast(Dict[str, Any], db.read_rows(table_name, {}))
                 if not result.get("success"):
                     return f"Error: Could not access table '{table_name}'. Please check if it exists."
                 
@@ -55,7 +55,7 @@ Please provide:
 Focus on actionable insights that could help improve how this information is stored and retrieved."""
             else:
                 # Analyze all tables
-                tables_result = db.list_tables()
+                tables_result = cast(Dict[str, Any], db.list_tables())
                 if not tables_result.get("success"):
                     return "Error: Could not access memory bank tables."
                 
@@ -63,10 +63,11 @@ Focus on actionable insights that could help improve how this information is sto
                 overview = {"tables": len(tables), "total_content": []}
                 
                 for table in tables[:5]:  # Limit to first 5 tables
-                    rows_result = db.read_rows(table, {})
+                    rows_result = cast(Dict[str, Any], db.read_rows(table, {}))
                     if rows_result.get("success"):
                         rows = rows_result.get("rows", [])
-                        overview["total_content"].append({
+                        total_content = cast(List[Any], overview["total_content"])
+                        total_content.append({
                             "table": table,
                             "rows": len(rows),
                             "sample": rows[:2] if rows else []
@@ -93,7 +94,7 @@ Focus on high-level strategic insights about the memory bank's utility and organ
             db = get_database(self.db_path)
             
             # Perform search
-            result = db.search_content(query, None, max_results or 10)
+            result = cast(Dict[str, Any], db.search_content(query, None, max_results or 10))
             if not result.get("success"):
                 return f"Error: Could not search for '{query}'. {result.get('error', 'Unknown error')}"
             
@@ -130,7 +131,7 @@ Use this information to provide a thorough, well-organized response that synthes
             db = get_database(self.db_path)
             
             # Try to find technical_decisions table
-            tables_result = db.list_tables()
+            tables_result = cast(Dict[str, Any], db.list_tables())
             if not tables_result.get("success"):
                 return "Error: Could not access memory bank."
             
@@ -162,7 +163,8 @@ The table should include fields like: decision_name, chosen_approach, rationale,
             
             # Format decisions for analysis
             formatted_decisions = []
-            for i, decision in enumerate(decisions, 1):
+            decisions_list = cast(List[Dict[str, Any]], decisions)
+            for i, decision in enumerate(decisions_list, 1):
                 formatted_decisions.append(f"{i}. Decision: {decision.get('decision_name', 'Unknown')}")
                 formatted_decisions.append(f"   Approach: {decision.get('chosen_approach', 'Not specified')}")
                 formatted_decisions.append(f"   Rationale: {decision.get('rationale', 'Not provided')}")
@@ -215,19 +217,21 @@ Focus on actionable insights that can improve technical decision-making processe
             }
             
             if context_type == "brief":
+                tables_list = cast(List[str], tables)
                 prompt = f"""Memory Bank Context (Brief):
-Available tables: {', '.join(tables)}
-Total tables: {len(tables)}
+Available tables: {', '.join(tables_list)}
+Total tables: {len(tables_list)}
 
 This memory bank contains structured information that can be searched and analyzed. Use the available tools to access specific content as needed."""
             else:
                 # Get sample content from a few tables
                 sample_content = {}
-                for table in tables[:3]:  # Sample from first 3 tables
+                tables_list = cast(List[str], tables)
+                for table in tables_list[:3]:  # Sample from first 3 tables
                     try:
-                        result = db.read_rows(table, {})
+                        result = cast(Dict[str, Any], db.read_rows(table, {}))
                         if result.get("success"):
-                            rows = result.get("rows", [])
+                            rows = cast(List[Any], result.get("rows", []))
                             sample_content[table] = {
                                 "row_count": len(rows),
                                 "sample_row": rows[0] if rows else None

{mcp_sqlite_memory_bank-1.4.1 → mcp_sqlite_memory_bank-1.4.3}/src/mcp_sqlite_memory_bank/resources.py

@@ -11,6 +11,7 @@ the standardized MCP protocol.
 Author: Robert Meisner
 """
 
+from typing import Dict, Any, cast
 from fastmcp import FastMCP
 from .database import get_database
 import json
@@ -31,7 +32,7 @@ class MemoryBankResources:
         async def get_tables_list() -> str:
             """Provide a list of all available tables as an MCP resource."""
             db = get_database(self.db_path)
-            result = db.list_tables()
+            result = cast(Dict[str, Any], db.list_tables())
             
             if not result.get("success"):
                 return json.dumps({"error": "Failed to fetch tables", "details": result})
@@ -50,7 +51,7 @@ class MemoryBankResources:
         async def get_table_schema(table_name: str) -> str:
             """Provide table schema information as an MCP resource."""
             db = get_database(self.db_path)
-            result = db.describe_table(table_name)
+            result = cast(Dict[str, Any], db.describe_table(table_name))
             
             if not result.get("success"):
                 return json.dumps({"error": f"Failed to fetch schema for table '{table_name}'", "details": result})
@@ -70,7 +71,7 @@ class MemoryBankResources:
         async def get_table_data(table_name: str) -> str:
             """Provide table data as an MCP resource."""
             db = get_database(self.db_path)
-            result = db.read_rows(table_name, {})
+            result = cast(Dict[str, Any], db.read_rows(table_name, {}))
             
             if not result.get("success"):
                 return json.dumps({"error": f"Failed to fetch data for table '{table_name}'", "details": result})
@@ -91,7 +92,7 @@ class MemoryBankResources:
         async def search_memory_content(query: str) -> str:
             """Provide search results as an MCP resource."""
             db = get_database(self.db_path)
-            result = db.search_content(query, None, 50)  # Search all tables, limit to 50 results
+            result = cast(Dict[str, Any], db.search_content(query, None, 50))  # Search all tables, limit to 50 results
             
             if not result.get("success"):
                 return json.dumps({"error": f"Failed to search for '{query}'", "details": result})
@@ -114,7 +115,7 @@ class MemoryBankResources:
             db = get_database(self.db_path)
             
             # Get table list
-            tables_result = db.list_tables()
+            tables_result = cast(Dict[str, Any], db.list_tables())
             if not tables_result.get("success"):
                 return json.dumps({"error": "Failed to fetch memory overview", "details": tables_result})
             
@@ -125,7 +126,7 @@ class MemoryBankResources:
             # Get row counts for each table
             for table in tables:
                 try:
-                    rows_result = db.read_rows(table, {})
+                    rows_result = cast(Dict[str, Any], db.read_rows(table, {}))
                     if rows_result.get("success"):
                         row_count = len(rows_result.get("rows", []))
                         table_stats[table] = {
@@ -144,13 +145,24 @@ class MemoryBankResources:
                         "status": f"error: {str(e)}"
                     }
             
+            # Find largest table
+            largest_table = None
+            if table_stats:
+                max_rows = 0
+                for table_name, stats in table_stats.items():
+                    row_count_obj = stats.get("row_count", 0)
+                    row_count = int(row_count_obj) if isinstance(row_count_obj, (int, str)) else 0
+                    if row_count > max_rows:
+                        max_rows = row_count
+                        largest_table = table_name
+
             resource_content = {
                 "resource_type": "memory_overview",
                 "description": "Overview of memory bank contents and usage",
                 "summary": {
                     "total_tables": len(tables),
                     "total_rows": total_rows,
-                    "largest_table": max(table_stats.items(), key=lambda x: x[1]["row_count"])[0] if table_stats else None
+                    "largest_table": largest_table
                 },
                 "table_statistics": table_stats,
                 "last_updated": "dynamic"

{mcp_sqlite_memory_bank-1.4.1 → mcp_sqlite_memory_bank-1.4.3}/src/mcp_sqlite_memory_bank/semantic.py

@@ -19,8 +19,8 @@ try:
     SENTENCE_TRANSFORMERS_AVAILABLE = True
 except ImportError:
     SENTENCE_TRANSFORMERS_AVAILABLE = False
-    SentenceTransformer = None
-    util = None
+    SentenceTransformer = None  # type: ignore
+    util = None  # type: ignore
     logging.warning("sentence-transformers not available. Install with: pip install sentence-transformers")
 
 try:
@@ -29,7 +29,7 @@ try:
     TORCH_AVAILABLE = True
 except ImportError:
     TORCH_AVAILABLE = False
-    torch = None
+    torch = None  # type: ignore
     logging.warning("torch not available. Install with: pip install torch")
 
 from .types import ValidationError, DatabaseError
@@ -50,7 +50,7 @@ class SemanticSearchEngine:
         """Initialize the semantic search engine."""
         self.model_name = model_name
         self._model = None
-        self._embedding_cache = {}
+        self._embedding_cache: Dict[str, Any] = {}
 
         if not SENTENCE_TRANSFORMERS_AVAILABLE:
             raise ValueError(

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

@@ -470,7 +470,12 @@ def add_embeddings(
     table_name: str, text_columns: List[str], embedding_column: str = "embedding", model_name: str = "all-MiniLM-L6-v2"
 ) -> ToolResponse:
     """
+    ⚠️  **ADVANCED TOOL** - Most agents should use auto_smart_search() instead!
+    
     Generate and store vector embeddings for semantic search on table content.
+    
+    **RECOMMENDATION**: Use auto_smart_search() or auto_semantic_search() for automatic setup.
+    This tool is for advanced users who need manual control over embedding generation.
 
     This tool enables intelligent knowledge discovery by creating vector representations
     of text content that can be searched semantically rather than just by exact keywords.
@@ -511,7 +516,12 @@ def semantic_search(
     model_name: str = "all-MiniLM-L6-v2",
 ) -> ToolResponse:
     """
+    ⚠️  **ADVANCED TOOL** - Most agents should use auto_smart_search() instead!
+    
     Find content using natural language semantic similarity rather than exact keyword matching.
+    
+    **RECOMMENDATION**: Use auto_smart_search() for automatic setup and hybrid search capabilities.
+    This tool requires manual embedding setup via add_embeddings() first.
 
     This enables intelligent knowledge discovery - find related concepts even when
     they use different terminology or phrasing.
@@ -610,7 +620,12 @@ def smart_search(
     model_name: str = "all-MiniLM-L6-v2",
 ) -> ToolResponse:
     """
+    ⚠️  **ADVANCED TOOL** - Most agents should use auto_smart_search() instead!
+    
     Intelligent hybrid search combining semantic understanding with keyword matching.
+    
+    **RECOMMENDATION**: Use auto_smart_search() for the same functionality with automatic setup.
+    This tool requires manual embedding setup via add_embeddings() first.
 
     Provides the best of both worlds - semantic similarity for concept discovery
     plus exact text matching for precise searches.
@@ -639,7 +654,7 @@ def smart_search(
         - Provides separate scores for transparency
         - Falls back gracefully if semantic search unavailable
         - Optimal for both exploratory and precise searches
-        - Recommended for general-purpose knowledge discovery
+        - Perfect for agents - ultimate search tool that just works!
     """
     return cast(
         ToolResponse,
@@ -649,8 +664,250 @@ def smart_search(
     )
 
 
+# --- Auto-Embedding Semantic Search Tools ---
+
+
+@mcp.tool
+@catch_errors
+def auto_semantic_search(
+    query: str,
+    tables: Optional[List[str]] = None,
+    similarity_threshold: float = 0.5,
+    limit: int = 10,
+    model_name: str = "all-MiniLM-L6-v2",
+) -> ToolResponse:
+    """
+    🚀 **ZERO-SETUP SEMANTIC SEARCH** - Just search, embeddings are handled automatically!
+
+    Find content using natural language semantic similarity. If embeddings don't exist,
+    they will be automatically generated for text columns. This is the easiest way to
+    do semantic search - no manual setup required!
+
+    Args:
+        query (str): Natural language search query
+        tables (Optional[List[str]]): Specific tables to search (default: all tables)
+        similarity_threshold (float): Minimum similarity score (0.0-1.0, default: 0.5)
+        limit (int): Maximum number of results to return (default: 10)
+        model_name (str): Model to use for embeddings (default: "all-MiniLM-L6-v2")
+
+    Returns:
+        ToolResponse: On success: {"success": True, "results": List[...], "auto_embedded_tables": List[str]}
+                     On error: {"success": False, "error": str, "category": str, "details": dict}
+
+    Examples:
+        >>> auto_semantic_search("API design patterns")
+        {"success": True, "results": [
+            {"table_name": "technical_decisions", "similarity_score": 0.87, "decision_name": "REST API Structure", ...}
+        ], "auto_embedded_tables": ["technical_decisions"]}
+
+        >>> auto_semantic_search("machine learning concepts")
+        # Finds content about "ML", "AI", "neural networks", etc.
+        # Automatically creates embeddings if they don't exist!
+
+    FastMCP Tool Info:
+        - **COMPLETELY AUTOMATIC**: No manual embedding setup required
+        - Auto-detects text columns and creates embeddings as needed
+        - Works across multiple tables simultaneously
+        - Finds conceptually similar content regardless of exact wording
+        - Returns relevance scores for ranking results
+        - Supports fuzzy matching and concept discovery
+        - Perfect for agents - just search and it works!
+    """
+    try:
+        db = get_database(DB_PATH)
+        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)
+            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
+        
+        # Perform semantic search
+        search_result = db.semantic_search(
+            query, search_tables, "embedding", None, similarity_threshold, limit, model_name
+        )
+        
+        # Add auto-embedding info to result
+        if isinstance(search_result, dict):
+            search_result["auto_embedded_tables"] = auto_embedded_tables
+            if auto_embedded_tables:
+                search_result["auto_embedding_note"] = f"Automatically generated embeddings for {len(auto_embedded_tables)} table(s)"
+        
+        return cast(ToolResponse, search_result)
+        
+    except Exception as e:
+        return cast(ToolResponse, {
+            "success": False,
+            "error": f"Auto semantic search failed: {str(e)}",
+            "category": "SEMANTIC_SEARCH_ERROR",
+            "details": {"query": query, "tables": tables}
+        })
+
+
 @mcp.tool
 @catch_errors
+def auto_smart_search(
+    query: str,
+    tables: Optional[List[str]] = None,
+    semantic_weight: float = 0.7,
+    text_weight: float = 0.3,
+    limit: int = 10,
+    model_name: str = "all-MiniLM-L6-v2",
+) -> ToolResponse:
+    """
+    🚀 **ZERO-SETUP HYBRID SEARCH** - Best of both worlds with automatic embedding!
+
+    Intelligent hybrid search combining semantic understanding with keyword matching.
+    Automatically generates embeddings for text columns when needed. This is the
+    ultimate search tool - no manual setup required!
+
+    Args:
+        query (str): Search query (natural language or keywords)
+        tables (Optional[List[str]]): Tables to search (default: all)
+        semantic_weight (float): Weight for semantic similarity (0.0-1.0, default: 0.7)
+        text_weight (float): Weight for keyword matching (0.0-1.0, default: 0.3)
+        limit (int): Maximum results (default: 10)
+        model_name (str): Semantic model to use (default: "all-MiniLM-L6-v2")
+
+    Returns:
+        ToolResponse: On success: {"success": True, "results": List[...], "search_type": "auto_hybrid"}
+                     On error: {"success": False, "error": str, "category": str, "details": dict}
+
+    Examples:
+        >>> auto_smart_search("user authentication security")
+        {"success": True, "results": [
+            {"combined_score": 0.89, "semantic_score": 0.92, "text_score": 0.82, ...}
+        ], "search_type": "auto_hybrid", "auto_embedded_tables": ["user_data"]}
+
+    FastMCP Tool Info:
+        - **COMPLETELY AUTOMATIC**: No manual embedding setup required
+        - Automatically balances semantic and keyword search
+        - Auto-detects text columns and creates embeddings as needed
+        - Provides separate scores for transparency
+        - Falls back gracefully if semantic search unavailable
+        - Optimal for both exploratory and precise searches
+        - Perfect for agents - ultimate search tool that just works!
+    """
+    try:
+        db = get_database(DB_PATH)
+        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)
+            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)
+        hybrid_result = db.hybrid_search(
+            query, tables, None, "embedding", semantic_weight, text_weight, limit, model_name
+        )
+        
+        # Add auto-embedding info to result
+        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:
+                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, {
+            "success": False,
+            "error": f"Auto smart search failed: {str(e)}",
+            "category": "HYBRID_SEARCH_ERROR", 
+            "details": {"query": query, "tables": tables}
+        })
+
+
+@mcp.tool
+@catch_errors 
 def embedding_stats(table_name: str, embedding_column: str = "embedding") -> ToolResponse:
     """
     Get statistics about semantic search readiness for a table.
@@ -672,7 +929,7 @@ def embedding_stats(table_name: str, embedding_column: str = "embedding") -> Too
 
     FastMCP Tool Info:
         - Shows how much content is ready for semantic search
-        - Helps identify tables that need embedding generation
+        - Helps identify tables that need embedding generation  
         - Provides embedding dimension info for debugging
         - Useful for monitoring semantic search capabilities
     """
@@ -792,9 +1049,6 @@ def get_tools_by_category(category: str) -> ToolResponse:
     })
 
 
-# ...existing code...
-
-
 # Export the FastMCP app for use in other modules and server runners
 app = mcp
 

{mcp_sqlite_memory_bank-1.4.1 → 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.1 → 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.1
+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