mcp-sqlite-memory-bank 1.4.3__py3-none-any.whl → 1.5.0__py3-none-any.whl

mcp_sqlite_memory_bank/__init__.py

@@ -25,15 +25,25 @@ from .server import (
     update_rows,
     delete_rows,
     run_select_query,
-    # Search tools
-    search_content,
-    explore_tables,
     # FastMCP app
     app,
     # Constants
     DB_PATH,
 )
 
+# Import search tools from the tools module
+from .tools import (
+    # Search tools
+    search_content,
+    explore_tables,
+    add_embeddings,
+    semantic_search,
+    find_related,
+    smart_search,
+    embedding_stats,
+    auto_semantic_search,
+    auto_smart_search,
+)
 
 from .types import (
     # Response types
@@ -81,6 +91,13 @@ __all__ = [
     # Search tools
     "search_content",
     "explore_tables",
+    "add_embeddings",
+    "semantic_search",
+    "find_related", 
+    "smart_search",
+    "embedding_stats",
+    "auto_semantic_search",
+    "auto_smart_search",
     # FastMCP app
     "app",
     # Constants

mcp_sqlite_memory_bank/database.py

@@ -403,27 +403,65 @@ class SQLiteMemoryDatabase:
                     for row in conn.execute(stmt).fetchall():
                         row_dict = dict(row._mapping)
 
-                        # Calculate relevance and matched content
-                        relevance = 0.0
+                        # Enhanced relevance calculation with multiple scoring factors
+                        relevance_scores = []
                         matched_content = []
                         query_lower = query.lower()
+                        query_terms = query_lower.split()
 
                         for col in text_columns:
                             if col.name in row_dict and row_dict[col.name]:
                                 content = str(row_dict[col.name]).lower()
+                                content_length = len(content)
+                                
                                 if query_lower in content:
-                                    frequency = content.count(query_lower)
-                                    relevance += frequency / len(content)
-                                    matched_content.append(f"{col.name}: {row_dict[col.name]}")
-
-                        if relevance > 0:
+                                    # Factor 1: Exact phrase frequency (weighted higher)
+                                    exact_frequency = content.count(query_lower)
+                                    exact_score = (exact_frequency * 2.0) / content_length if content_length > 0 else 0
+                                    
+                                    # Factor 2: Individual term frequency
+                                    term_score = 0.0
+                                    for term in query_terms:
+                                        if term in content:
+                                            term_score += content.count(term) / content_length if content_length > 0 else 0
+                                    
+                                    # Factor 3: Position bonus (early matches score higher)
+                                    position_bonus = 0.0
+                                    first_occurrence = content.find(query_lower)
+                                    if first_occurrence != -1:
+                                        position_bonus = (content_length - first_occurrence) / content_length * 0.1
+                                    
+                                    # Factor 4: Column importance (title/name columns get bonus)
+                                    column_bonus = 0.0
+                                    if any(keyword in col.name.lower() for keyword in ['title', 'name', 'summary', 'description']):
+                                        column_bonus = 0.2
+                                    
+                                    # Combined relevance score
+                                    col_relevance = exact_score + term_score + position_bonus + column_bonus
+                                    relevance_scores.append(col_relevance)
+                                    
+                                    # Enhanced matched content with context
+                                    snippet_start = max(0, first_occurrence - 50)
+                                    snippet_end = min(len(row_dict[col.name]), first_occurrence + len(query) + 50)
+                                    snippet = str(row_dict[col.name])[snippet_start:snippet_end]
+                                    if snippet_start > 0:
+                                        snippet = "..." + snippet
+                                    if snippet_end < len(str(row_dict[col.name])):
+                                        snippet = snippet + "..."
+                                    
+                                    matched_content.append(f"{col.name}: {snippet}")
+
+                        total_relevance = sum(relevance_scores)
+                        if total_relevance > 0:
                             results.append(
                                 {
                                     "table": table_name,
                                     "row_id": row_dict.get("id"),
                                     "row_data": row_dict,
                                     "matched_content": matched_content,
-                                    "relevance": round(relevance, 3),
+                                    "relevance": round(total_relevance, 4),
+                                    "match_quality": "high" if total_relevance > 0.5 else "medium" if total_relevance > 0.1 else "low",
+                                    "match_count": len(relevance_scores)
                                 }
                             )
 
@@ -910,10 +948,20 @@ class SQLiteMemoryDatabase:
                 )
 
             # Enhance with text matching scores
-            semantic_engine = get_semantic_engine(model_name)
-            enhanced_results = semantic_engine.hybrid_search(
-                query, semantic_results, text_columns or [], embedding_column, semantic_weight, text_weight, limit
-            )
+            try:
+                semantic_engine = get_semantic_engine(model_name)
+                
+                # Verify the engine has the required method
+                if not hasattr(semantic_engine, 'hybrid_search') or not callable(getattr(semantic_engine, 'hybrid_search')):
+                    raise DatabaseError("Semantic engine hybrid_search method is not callable")
+                
+                enhanced_results = semantic_engine.hybrid_search(
+                    query, semantic_results, text_columns or [], embedding_column, semantic_weight, text_weight, limit
+                )
+            except Exception as e:
+                # If semantic enhancement fails, return semantic results without text enhancement
+                logging.warning(f"Semantic enhancement failed: {e}")
+                enhanced_results = semantic_results[:limit]
 
             return {
                 "success": True,

mcp_sqlite_memory_bank/resources.py

@@ -14,6 +14,7 @@ Author: Robert Meisner
 from typing import Dict, Any, cast
 from fastmcp import FastMCP
 from .database import get_database
+from .semantic import is_semantic_search_available
 import json
 
 
@@ -169,6 +170,261 @@ class MemoryBankResources:
             }
             
             return json.dumps(resource_content, indent=2)
+        
+        @self.mcp.resource("memory://live/recent-activity")
+        async def get_recent_activity() -> str:
+            """Real-time feed of recent memory bank changes and activity."""
+            db = get_database(self.db_path)
+            
+            # Get tables with timestamp columns for activity tracking
+            tables_result = cast(Dict[str, Any], db.list_tables())
+            if not tables_result.get("success"):
+                return json.dumps({"error": "Failed to get tables", "details": tables_result})
+            
+            recent_activity = []
+            tables = tables_result.get("tables", [])
+            
+            for table_name in tables:
+                try:
+                    # Check if table has timestamp column
+                    schema_result = cast(Dict[str, Any], db.describe_table(table_name))
+                    if not schema_result.get("success"):
+                        continue
+                    
+                    columns = schema_result.get("columns", [])
+                    timestamp_cols = [col for col in columns if "timestamp" in col.get("name", "").lower()]
+                    
+                    if timestamp_cols:
+                        # Get recent entries (last 10)
+                        recent_result = cast(Dict[str, Any], db.read_rows(table_name, None, 10))
+                        if recent_result.get("success"):
+                            rows = recent_result.get("rows", [])
+                            for row in rows:
+                                activity_entry = {
+                                    "table": table_name,
+                                    "action": "content_added",
+                                    "timestamp": row.get(timestamp_cols[0]["name"]),
+                                    "content_preview": str(row).replace('"', "'")[:100] + "..." if len(str(row)) > 100 else str(row),
+                                    "row_id": row.get("id")
+                                }
+                                recent_activity.append(activity_entry)
+                
+                except Exception as e:
+                    continue
+            
+            # Sort by timestamp (most recent first)
+            recent_activity.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+            recent_activity = recent_activity[:20]  # Limit to 20 most recent
+            
+            resource_content = {
+                "resource_type": "recent_activity",
+                "description": "Recent changes and additions to the memory bank",
+                "activities": recent_activity,
+                "activity_count": len(recent_activity),
+                "last_updated": "real-time",
+                "refresh_rate": "dynamic"
+            }
+            
+            return json.dumps(resource_content, indent=2)
+        
+        @self.mcp.resource("memory://live/content-suggestions")
+        async def get_content_suggestions() -> str:
+            """AI-powered suggestions for content improvements and organization."""
+            db = get_database(self.db_path)
+            
+            suggestions = {
+                "organization_suggestions": [],
+                "content_gaps": [],
+                "semantic_opportunities": [],
+                "quality_improvements": []
+            }
+            
+            try:
+                # Get basic analysis
+                tables_result = cast(Dict[str, Any], db.list_tables())
+                if not tables_result.get("success"):
+                    return json.dumps({"error": "Failed to analyze content", "details": tables_result})
+                
+                tables = tables_result.get("tables", [])
+                
+                for table_name in tables:
+                    try:
+                        # Analyze table content
+                        rows_result = cast(Dict[str, Any], db.read_rows(table_name))
+                        if not rows_result.get("success"):
+                            continue
+                        
+                        rows = rows_result.get("rows", [])
+                        
+                        # Check for organization opportunities
+                        if len(rows) > 50:
+                            suggestions["organization_suggestions"].append({
+                                "table": table_name,
+                                "suggestion": "Consider adding categories or tags for better organization",
+                                "reason": f"Large table with {len(rows)} rows could benefit from categorization"
+                            })
+                        
+                        # Check for semantic search opportunities
+                        if is_semantic_search_available():
+                            embedding_stats = cast(Dict[str, Any], db.get_embedding_stats(table_name))
+                            if embedding_stats.get("success") and embedding_stats.get("coverage_percent", 0) == 0:
+                                schema_result = cast(Dict[str, Any], db.describe_table(table_name))
+                                if schema_result.get("success"):
+                                    text_cols = [col for col in schema_result.get("columns", []) 
+                                               if "TEXT" in col.get("type", "").upper()]
+                                    if text_cols and len(rows) > 5:
+                                        suggestions["semantic_opportunities"].append({
+                                            "table": table_name,
+                                            "suggestion": "Set up semantic search for better content discovery",
+                                            "reason": f"Table has {len(text_cols)} text columns and {len(rows)} rows",
+                                            "action": f"Use add_embeddings('{table_name}', {[col['name'] for col in text_cols[:3]]})"
+                                        })
+                        
+                        # Check for content gaps (sparse tables)
+                        if 1 <= len(rows) <= 5:
+                            suggestions["content_gaps"].append({
+                                "table": table_name,
+                                "suggestion": "Consider adding more content or consolidating with other tables",
+                                "reason": f"Table has only {len(rows)} rows - might be underutilized"
+                            })
+                        
+                        # Sample content for quality analysis
+                        if rows:
+                            sample_row = rows[0]
+                            short_values = [k for k, v in sample_row.items() 
+                                          if isinstance(v, str) and 0 < len(v) < 10]
+                            if len(short_values) > 2:
+                                suggestions["quality_improvements"].append({
+                                    "table": table_name,
+                                    "suggestion": "Consider adding more detailed content",
+                                    "reason": f"Several columns have very short values: {short_values[:3]}"
+                                })
+                    
+                    except Exception as e:
+                        continue
+                
+                # Prioritize suggestions
+                priority_order = ["semantic_opportunities", "organization_suggestions", "quality_improvements", "content_gaps"]
+                prioritized = {}
+                for category in priority_order:
+                    if suggestions[category]:
+                        prioritized[category] = suggestions[category]
+                
+                resource_content = {
+                    "resource_type": "content_suggestions",
+                    "description": "AI-powered suggestions for improving your memory bank",
+                    "suggestions": prioritized,
+                    "total_suggestions": sum(len(v) for v in suggestions.values()),
+                    "last_updated": "real-time",
+                    "next_actions": [
+                        "Review semantic opportunities for high-value tables",
+                        "Consider organization improvements for large tables",
+                        "Add more detailed content where suggested"
+                    ]
+                }
+                
+                return json.dumps(resource_content, indent=2)
+                
+            except Exception as e:
+                return json.dumps({
+                    "error": f"Failed to generate content suggestions: {str(e)}",
+                    "suggestions": suggestions
+                })
+        
+        @self.mcp.resource("memory://analytics/insights")
+        async def get_memory_insights() -> str:
+            """Real-time analytics and insights about memory bank usage and patterns."""
+            db = get_database(self.db_path)
+            
+            insights = {
+                "usage_patterns": {},
+                "content_trends": {},
+                "search_recommendations": {},
+                "health_indicators": {}
+            }
+            
+            try:
+                tables_result = cast(Dict[str, Any], db.list_tables())
+                if not tables_result.get("success"):
+                    return json.dumps({"error": "Failed to get insights", "details": tables_result})
+                
+                tables = tables_result.get("tables", [])
+                total_rows = 0
+                content_quality_scores = []
+                
+                for table_name in tables:
+                    rows_result = cast(Dict[str, Any], db.read_rows(table_name))
+                    if rows_result.get("success"):
+                        rows = rows_result.get("rows", [])
+                        row_count = len(rows)
+                        total_rows += row_count
+                        
+                        # Calculate content quality score for this table
+                        if rows:
+                            # Sample content to estimate quality
+                            sample_size = min(5, len(rows))
+                            total_content_length = 0
+                            for row in rows[:sample_size]:
+                                for value in row.values():
+                                    if isinstance(value, str):
+                                        total_content_length += len(value)
+                            
+                            avg_content_length = total_content_length / sample_size if sample_size > 0 else 0
+                            quality_score = min(10, avg_content_length / 50)  # Normalize to 0-10
+                            content_quality_scores.append(quality_score)
+                            
+                            insights["usage_patterns"][table_name] = {
+                                "row_count": row_count,
+                                "avg_content_length": round(avg_content_length),
+                                "quality_score": round(quality_score, 1),
+                                "category": "high_value" if quality_score > 7 else "medium_value" if quality_score > 3 else "low_value"
+                            }
+                
+                # Overall health indicators
+                avg_quality = sum(content_quality_scores) / len(content_quality_scores) if content_quality_scores else 0
+                insights["health_indicators"] = {
+                    "total_tables": len(tables),
+                    "total_content_rows": total_rows,
+                    "average_content_quality": round(avg_quality, 1),
+                    "content_distribution": "balanced" if len(tables) > 0 and total_rows / len(tables) > 10 else "sparse",
+                    "semantic_readiness": "available" if is_semantic_search_available() else "unavailable"
+                }
+                
+                # Search recommendations
+                high_value_tables = [name for name, data in insights["usage_patterns"].items() 
+                                   if data.get("category") == "high_value"]
+                
+                if high_value_tables:
+                    insights["search_recommendations"]["intelligent_search"] = {
+                        "recommended_tables": high_value_tables,
+                        "strategy": "Use intelligent_search() for best results across high-value content"
+                    }
+                
+                if is_semantic_search_available():
+                    insights["search_recommendations"]["semantic_opportunities"] = {
+                        "suggestion": "Consider semantic search for conceptual queries",
+                        "best_for": "Finding related concepts, patterns, and thematic content"
+                    }
+                
+                resource_content = {
+                    "resource_type": "memory_insights",
+                    "description": "Real-time analytics and insights about your memory bank",
+                    "insights": insights,
+                    "last_updated": "real-time",
+                    "recommendations": [
+                        f"Focus on high-value tables: {', '.join(high_value_tables[:3])}" if high_value_tables else "Add more detailed content to improve value",
+                        "Use intelligent_search() for optimal search results",
+                        "Consider semantic search setup for better content discovery" if is_semantic_search_available() else "Install sentence-transformers for semantic search"
+                    ]
+                }
+                
+                return json.dumps(resource_content, indent=2)
+                
+            except Exception as e:
+                return json.dumps({
+                    "error": f"Failed to generate insights: {str(e)}",
+                    "insights": insights
+                })
 
 
 def setup_mcp_resources(mcp_app: FastMCP, db_path: str) -> MemoryBankResources:

mcp_sqlite_memory_bank/semantic.py

@@ -387,10 +387,20 @@ def get_semantic_engine(model_name: str = "all-MiniLM-L6-v2") -> SemanticSearchE
     """Get or create the global semantic search engine."""
     global _semantic_engine
 
-    if _semantic_engine is None or _semantic_engine.model_name != model_name:
-        _semantic_engine = SemanticSearchEngine(model_name)
-
-    return _semantic_engine
+    try:
+        if _semantic_engine is None or _semantic_engine.model_name != model_name:
+            if not SENTENCE_TRANSFORMERS_AVAILABLE:
+                raise ValueError("Sentence transformers not available for semantic search")
+            _semantic_engine = SemanticSearchEngine(model_name)
+        
+        # Verify the engine is properly initialized
+        if not hasattr(_semantic_engine, 'hybrid_search'):
+            raise ValueError("Semantic engine missing hybrid_search method")
+            
+        return _semantic_engine
+        
+    except Exception as e:
+        raise DatabaseError(f"Failed to initialize semantic engine: {e}")
 
 
 def is_semantic_search_available() -> bool: