mcp-sqlite-memory-bank 1.3.1__py3-none-any.whl → 1.4.2__py3-none-any.whl

mcp_sqlite_memory_bank/database.py

@@ -429,7 +429,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 +458,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 +466,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 +481,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 +498,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
 
@@ -1001,6 +1006,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/prompts.py

@@ -0,0 +1,256 @@
+"""
+MCP Prompts Support for SQLite Memory Bank
+=========================================
+
+This module adds MCP Prompts support, providing templated prompts and workflows
+that leverage the memory bank content for enhanced AI interactions.
+
+Prompts provide reusable, contextual templates that can dynamically incorporate
+stored memory content into LLM conversations.
+
+Author: Robert Meisner
+"""
+
+from typing import Optional, Dict, List, Any, cast
+from fastmcp import FastMCP
+from .database import get_database
+import json
+
+
+class MemoryBankPrompts:
+    """Manages MCP Prompts for the SQLite Memory Bank."""
+    
+    def __init__(self, mcp_app: FastMCP, db_path: str):
+        self.mcp = mcp_app
+        self.db_path = db_path
+        self._register_prompts()
+    
+    def _register_prompts(self):
+        """Register MCP prompts with the FastMCP app."""
+        
+        @self.mcp.prompt("analyze-memory-content")
+        async def analyze_memory_content(table_name: Optional[str] = None) -> str:
+            """Analyze memory bank content and provide insights."""
+            db = get_database(self.db_path)
+            
+            if table_name:
+                # Analyze specific table
+                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."
+                
+                rows = result.get("rows", [])
+                prompt = f"""Please analyze the content in the '{table_name}' table from the memory bank.
+
+Table: {table_name}
+Row count: {len(rows)}
+Sample data: {json.dumps(rows[:3], indent=2) if rows else "No data"}
+
+Please provide:
+1. A summary of the content patterns
+2. Key insights or themes
+3. Suggestions for better organization
+4. Potential use cases for this data
+
+Focus on actionable insights that could help improve how this information is stored and retrieved."""
+            else:
+                # Analyze all tables
+                tables_result = cast(Dict[str, Any], db.list_tables())
+                if not tables_result.get("success"):
+                    return "Error: Could not access memory bank tables."
+                
+                tables = tables_result.get("tables", [])
+                overview = {"tables": len(tables), "total_content": []}
+                
+                for table in tables[:5]:  # Limit to first 5 tables
+                    rows_result = cast(Dict[str, Any], db.read_rows(table, {}))
+                    if rows_result.get("success"):
+                        rows = rows_result.get("rows", [])
+                        total_content = cast(List[Any], overview["total_content"])
+                        total_content.append({
+                            "table": table,
+                            "rows": len(rows),
+                            "sample": rows[:2] if rows else []
+                        })
+                
+                prompt = f"""Please analyze the overall content in this memory bank.
+
+Memory Bank Overview:
+{json.dumps(overview, indent=2)}
+
+Please provide:
+1. Assessment of content organization
+2. Identification of content patterns across tables
+3. Recommendations for improving memory structure
+4. Suggestions for leveraging this content more effectively
+
+Focus on high-level strategic insights about the memory bank's utility and organization."""
+            
+            return prompt
+        
+        @self.mcp.prompt("search-and-summarize")
+        async def search_and_summarize(query: str, max_results: Optional[int] = 10) -> str:
+            """Search memory content and create a summary prompt."""
+            db = get_database(self.db_path)
+            
+            # Perform search
+            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')}"
+            
+            search_results = result.get("results", [])
+            if not search_results:
+                return f"No results found for query: '{query}'. Please try different search terms or check if relevant content exists in the memory bank."
+            
+            # Format results for prompt
+            formatted_results = []
+            for i, result in enumerate(search_results[:max_results or 10], 1):
+                formatted_results.append(f"{i}. Table: {result.get('table', 'unknown')}")
+                formatted_results.append(f"   Content: {result.get('content', 'No content')[:200]}...")
+                formatted_results.append(f"   Relevance: {result.get('relevance', 'N/A')}")
+                formatted_results.append("")
+            
+            prompt = f"""Based on the search query "{query}", here are the most relevant results from the memory bank:
+
+Search Results:
+{chr(10).join(formatted_results)}
+
+Please provide:
+1. A comprehensive summary of the key information found
+2. Common themes or patterns across the results
+3. Any gaps or additional information that might be needed
+4. Actionable insights based on this content
+
+Use this information to provide a thorough, well-organized response that synthesizes the search results."""
+            
+            return prompt
+        
+        @self.mcp.prompt("technical-decision-analysis")
+        async def technical_decision_analysis(decision_topic: Optional[str] = None) -> str:
+            """Analyze technical decisions from the memory bank."""
+            db = get_database(self.db_path)
+            
+            # Try to find technical_decisions table
+            tables_result = cast(Dict[str, Any], db.list_tables())
+            if not tables_result.get("success"):
+                return "Error: Could not access memory bank."
+            
+            tables = tables_result.get("tables", [])
+            if "technical_decisions" not in tables:
+                return """No technical decisions table found in the memory bank. 
+
+To use this prompt effectively, please:
+1. Create a 'technical_decisions' table
+2. Store your technical decisions with context
+3. Try this prompt again
+
+The table should include fields like: decision_name, chosen_approach, rationale, alternatives, timestamp."""
+            
+            # Get technical decisions
+            where_clause = {}
+            if decision_topic:
+                # This is a simplified search - in practice you'd want semantic search
+                where_clause = {"decision_name": decision_topic}
+            
+            result = db.read_rows("technical_decisions", where_clause)
+            if not result.get("success"):
+                return "Error: Could not read technical decisions."
+            
+            decisions = result.get("rows", [])
+            if not decisions:
+                topic_msg = f" related to '{decision_topic}'" if decision_topic else ""
+                return f"No technical decisions found{topic_msg}. Consider adding some decisions to the memory bank first."
+            
+            # Format decisions for analysis
+            formatted_decisions = []
+            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')}")
+                if decision.get('alternatives'):
+                    formatted_decisions.append(f"   Alternatives: {decision.get('alternatives')}")
+                formatted_decisions.append(f"   Date: {decision.get('timestamp', 'Unknown')}")
+                formatted_decisions.append("")
+            
+            prompt = f"""Please analyze these technical decisions from the memory bank:
+
+Technical Decisions{f" (filtered by: {decision_topic})" if decision_topic else ""}:
+{chr(10).join(formatted_decisions)}
+
+Please provide:
+1. Analysis of decision-making patterns
+2. Assessment of the rationale quality
+3. Identification of any decision dependencies or conflicts
+4. Recommendations for future decisions
+5. Suggestions for improving decision documentation
+
+Focus on actionable insights that can improve technical decision-making processes."""
+            
+            return prompt
+        
+        @self.mcp.prompt("memory-bank-context")
+        async def memory_bank_context(context_type: str = "full") -> str:
+            """Provide memory bank context for AI conversations."""
+            db = get_database(self.db_path)
+            
+            # Get overview
+            tables_result = db.list_tables()
+            if not tables_result.get("success"):
+                return "Error: Could not access memory bank for context."
+            
+            tables = tables_result.get("tables", [])
+            context_info = {
+                "available_tables": tables,
+                "capabilities": [
+                    "Full-text search across all content",
+                    "Semantic search (if embeddings are available)",
+                    "Structured data queries",
+                    "Content analytics and insights"
+                ],
+                "usage_suggestions": [
+                    "Use search_content() for finding specific information",
+                    "Use semantic_search() for conceptual queries",
+                    "Use read_rows() for structured data access",
+                    "Use explore_tables() to discover available content"
+                ]
+            }
+            
+            if context_type == "brief":
+                tables_list = cast(List[str], tables)
+                prompt = f"""Memory Bank Context (Brief):
+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 = {}
+                tables_list = cast(List[str], tables)
+                for table in tables_list[:3]:  # Sample from first 3 tables
+                    try:
+                        result = cast(Dict[str, Any], db.read_rows(table, {}))
+                        if result.get("success"):
+                            rows = cast(List[Any], result.get("rows", []))
+                            sample_content[table] = {
+                                "row_count": len(rows),
+                                "sample_row": rows[0] if rows else None
+                            }
+                    except Exception:
+                        continue
+                
+                prompt = f"""Memory Bank Context (Full):
+
+{json.dumps(context_info, indent=2)}
+
+Sample Content:
+{json.dumps(sample_content, indent=2)}
+
+This memory bank contains structured information that can be searched, analyzed, and leveraged for various tasks. The content is organized in tables with different types of information. Use the available search and query tools to access specific content as needed for your current task."""
+            
+            return prompt
+
+
+def setup_mcp_prompts(mcp_app: FastMCP, db_path: str) -> MemoryBankPrompts:
+    """Set up MCP Prompts for the memory bank."""
+    return MemoryBankPrompts(mcp_app, db_path)

mcp_sqlite_memory_bank/resources.py

@@ -0,0 +1,176 @@
+"""
+MCP Resources Support for SQLite Memory Bank
+==========================================
+
+This module adds MCP Resources support, allowing the memory bank to expose
+stored content as MCP resources that can be consumed by LLM applications.
+
+Resources provide context and data that can be accessed by AI models through
+the standardized MCP protocol.
+
+Author: Robert Meisner
+"""
+
+from typing import Dict, Any, cast
+from fastmcp import FastMCP
+from .database import get_database
+import json
+
+
+class MemoryBankResources:
+    """Manages MCP Resources for the SQLite Memory Bank."""
+    
+    def __init__(self, mcp_app: FastMCP, db_path: str):
+        self.mcp = mcp_app
+        self.db_path = db_path
+        self._register_resources()
+    
+    def _register_resources(self):
+        """Register MCP resources with the FastMCP app."""
+        
+        @self.mcp.resource("memory://tables/list")
+        async def get_tables_list() -> str:
+            """Provide a list of all available tables as an MCP resource."""
+            db = get_database(self.db_path)
+            result = cast(Dict[str, Any], db.list_tables())
+            
+            if not result.get("success"):
+                return json.dumps({"error": "Failed to fetch tables", "details": result})
+            
+            resource_content = {
+                "resource_type": "table_list",
+                "description": "List of all available tables in the memory bank",
+                "tables": result.get("tables", []),
+                "total_count": len(result.get("tables", [])),
+                "last_updated": "dynamic"
+            }
+            
+            return json.dumps(resource_content, indent=2)
+        
+        @self.mcp.resource("memory://tables/{table_name}/schema")
+        async def get_table_schema(table_name: str) -> str:
+            """Provide table schema information as an MCP resource."""
+            db = get_database(self.db_path)
+            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})
+            
+            resource_content = {
+                "resource_type": "table_schema",
+                "table_name": table_name,
+                "description": f"Schema definition for table '{table_name}'",
+                "columns": result.get("columns", []),
+                "column_count": len(result.get("columns", [])),
+                "last_updated": "dynamic"
+            }
+            
+            return json.dumps(resource_content, indent=2)
+        
+        @self.mcp.resource("memory://tables/{table_name}/data")
+        async def get_table_data(table_name: str) -> str:
+            """Provide table data as an MCP resource."""
+            db = get_database(self.db_path)
+            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})
+            
+            rows = result.get("rows", [])
+            resource_content = {
+                "resource_type": "table_data",
+                "table_name": table_name,
+                "description": f"All data from table '{table_name}'",
+                "rows": rows,
+                "row_count": len(rows),
+                "last_updated": "dynamic"
+            }
+            
+            return json.dumps(resource_content, indent=2)
+        
+        @self.mcp.resource("memory://search/{query}")
+        async def search_memory_content(query: str) -> str:
+            """Provide search results as an MCP resource."""
+            db = get_database(self.db_path)
+            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})
+            
+            search_results = result.get("results", [])
+            resource_content = {
+                "resource_type": "search_results",
+                "query": query,
+                "description": f"Search results for query: '{query}'",
+                "results": search_results,
+                "result_count": len(search_results),
+                "last_updated": "dynamic"
+            }
+            
+            return json.dumps(resource_content, indent=2)
+        
+        @self.mcp.resource("memory://analytics/overview")
+        async def get_memory_overview() -> str:
+            """Provide memory bank overview analytics as an MCP resource."""
+            db = get_database(self.db_path)
+            
+            # Get table list
+            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})
+            
+            tables = tables_result.get("tables", [])
+            total_rows = 0
+            table_stats = {}
+            
+            # Get row counts for each table
+            for table in tables:
+                try:
+                    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] = {
+                            "row_count": row_count,
+                            "status": "accessible"
+                        }
+                        total_rows += row_count
+                    else:
+                        table_stats[table] = {
+                            "row_count": 0,
+                            "status": "error"
+                        }
+                except Exception as e:
+                    table_stats[table] = {
+                        "row_count": 0,
+                        "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": largest_table
+                },
+                "table_statistics": table_stats,
+                "last_updated": "dynamic"
+            }
+            
+            return json.dumps(resource_content, indent=2)
+
+
+def setup_mcp_resources(mcp_app: FastMCP, db_path: str) -> MemoryBankResources:
+    """Set up MCP Resources for the memory bank."""
+    return MemoryBankResources(mcp_app, db_path)

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/server.py

@@ -65,6 +65,8 @@ from .types import (
     SelectQueryResponse,
 )
 from .utils import catch_errors
+from .resources import setup_mcp_resources
+from .prompts import setup_mcp_prompts
 
 # Initialize FastMCP app with explicit name
 mcp: FastMCP = FastMCP("SQLite Memory Bank for Copilot/AI Agents")
@@ -78,6 +80,12 @@ os.makedirs(os.path.dirname(os.path.abspath(DB_PATH)), exist_ok=True)
 # Initialize database
 db = get_database(DB_PATH)
 
+# Set up MCP Resources for enhanced context provision
+setup_mcp_resources(mcp, DB_PATH)
+
+# Set up MCP Prompts for enhanced workflow support
+setup_mcp_prompts(mcp, DB_PATH)
+
 
 # --- Schema Management Tools for SQLite Memory Bank ---
 
@@ -462,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.
@@ -503,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.
@@ -602,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.
@@ -631,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,
@@ -641,34 +664,306 @@ def smart_search(
     )
 
 
+# --- Auto-Embedding Semantic Search Tools ---
+
+
 @mcp.tool
 @catch_errors
-def embedding_stats(table_name: str, embedding_column: str = "embedding") -> ToolResponse:
+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:
     """
-    Get statistics about semantic search readiness for a table.
+    🚀 **ZERO-SETUP SEMANTIC SEARCH** - Just search, embeddings are handled automatically!
 
-    Check which content has embeddings and can be searched semantically.
+    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:
-        table_name (str): Table to analyze
-        embedding_column (str): Embedding column to check (default: "embedding")
+        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, "coverage_percent": float, "total_rows": int}
+        ToolResponse: On success: {"success": True, "results": List[...], "auto_embedded_tables": List[str]}
                      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}
+        >>> 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:
-        - 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
+        - **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 = []
+        
+        # Get tables to search
+        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", [])
+        
+        # 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:
+                    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 = []
+                for col in schema_result.get("columns", []):
+                    if "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:
+        # 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 = []
+        
+        if auto_semantic_result.get("success"):
+            auto_embedded_tables = auto_semantic_result.get("auto_embedded_tables", [])
+        
+        # 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):
+            hybrid_result["search_type"] = "auto_hybrid"
+            hybrid_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)
+        
+    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}
+        })
+
+
+# --- Enhanced Tool Discovery and Categorization ---
+
+
+@mcp.tool
+@catch_errors
+def list_tool_categories() -> ToolResponse:
+    """
+    List all available tool categories for better organization and discovery.
+    
+    Returns organized view of available functionality for LLMs and agents.
+    
+    Returns:
+        ToolResponse: {"success": True, "categories": {category: [tool_names]}}
+    """
+    categories = {
+        "schema_management": [
+            "create_table", "list_tables", "describe_table", 
+            "drop_table", "rename_table", "list_all_columns"
+        ],
+        "data_operations": [
+            "create_row", "read_rows", "update_rows", 
+            "delete_rows", "run_select_query"
+        ],
+        "search_discovery": [
+            "search_content", "explore_tables"
+        ],
+        "semantic_search": [
+            "add_embeddings", "semantic_search", "find_related", 
+            "smart_search", "embedding_stats"
+        ],
+        "workflow_shortcuts": [
+            "quick_note", "remember_decision", "store_context"
+        ],
+        "analytics_insights": [
+            "memory_usage_stats", "content_analytics"
+        ]
+    }
+    
+    return cast(ToolResponse, {
+        "success": True,
+        "categories": categories,
+        "total_tools": sum(len(tools) for tools in categories.values()),
+        "description": "Organized view of all available memory bank capabilities"
+    })
+
+
+@mcp.tool  
+@catch_errors
+def get_tools_by_category(category: str) -> ToolResponse:
+    """
+    Get detailed information about tools in a specific category.
+    
+    Args:
+        category (str): Category name (schema_management, data_operations, 
+                       search_discovery, semantic_search, workflow_shortcuts, analytics_insights)
+    
+    Returns:
+        ToolResponse: {"success": True, "tools": [{"name": str, "description": str, "usage": str}]}
     """
-    return cast(ToolResponse, get_database(DB_PATH).get_embedding_stats(table_name, embedding_column))
+    tool_details = {
+        "schema_management": [
+            {"name": "create_table", "description": "Create new tables with custom schemas", "usage": "create_table('table_name', [{'name': 'col', 'type': 'TEXT'}])"},
+            {"name": "list_tables", "description": "List all available tables", "usage": "list_tables()"},
+            {"name": "describe_table", "description": "Get detailed schema for a table", "usage": "describe_table('table_name')"},
+            {"name": "drop_table", "description": "Delete a table permanently", "usage": "drop_table('table_name')"},
+            {"name": "rename_table", "description": "Rename an existing table", "usage": "rename_table('old_name', 'new_name')"},
+            {"name": "list_all_columns", "description": "Get all columns across all tables", "usage": "list_all_columns()"},
+        ],
+        "data_operations": [
+            {"name": "create_row", "description": "Insert new data into any table", "usage": "create_row('table', {'col': 'value'})"},
+            {"name": "read_rows", "description": "Query data with optional filtering", "usage": "read_rows('table', {'filter_col': 'value'})"},
+            {"name": "update_rows", "description": "Modify existing data", "usage": "update_rows('table', {'new_data': 'value'}, {'where_col': 'value'})"},
+            {"name": "delete_rows", "description": "Remove data from tables", "usage": "delete_rows('table', {'filter_col': 'value'})"},
+            {"name": "run_select_query", "description": "Execute safe SELECT queries", "usage": "run_select_query('table', ['col1', 'col2'], {'filter': 'value'})"},
+        ],
+        "search_discovery": [
+            {"name": "search_content", "description": "Full-text search across all content", "usage": "search_content('search query', ['table1', 'table2'])"},
+            {"name": "explore_tables", "description": "Discover table structures and sample data", "usage": "explore_tables('pattern*')"},
+        ],
+        "semantic_search": [
+            {"name": "add_embeddings", "description": "Enable semantic search on tables", "usage": "add_embeddings('table', ['text_col1', 'text_col2'])"},
+            {"name": "semantic_search", "description": "Natural language content discovery", "usage": "semantic_search('find ML algorithms')"},
+            {"name": "find_related", "description": "Discover similar content", "usage": "find_related('table', row_id, 0.5)"},
+            {"name": "smart_search", "description": "Hybrid keyword + semantic search", "usage": "smart_search('search query')"},
+            {"name": "embedding_stats", "description": "Check semantic search readiness", "usage": "embedding_stats('table')"},
+        ],
+        "workflow_shortcuts": [
+            {"name": "quick_note", "description": "Rapidly store notes and observations", "usage": "quick_note('content', 'category')"},
+            {"name": "remember_decision", "description": "Store technical decisions with context", "usage": "remember_decision('decision', 'approach', 'rationale')"},
+            {"name": "store_context", "description": "Save session context and progress", "usage": "store_context('topic', 'current_state', 'next_steps')"},
+        ],
+        "analytics_insights": [
+            {"name": "memory_usage_stats", "description": "Analyze memory bank usage patterns", "usage": "memory_usage_stats()"},
+            {"name": "content_analytics", "description": "Get insights on stored content", "usage": "content_analytics('table_name')"},
+        ],
+    }
+    
+    if category not in tool_details:
+        return cast(ToolResponse, {
+            "success": False,
+            "error": f"Unknown category '{category}'. Available: {list(tool_details.keys())}",
+            "category": "VALIDATION",
+            "details": {"available_categories": list(tool_details.keys())},
+        })
+    
+    return cast(ToolResponse, {
+        "success": True,
+        "category": category,
+        "tools": tool_details[category],
+        "tool_count": len(tool_details[category]),
+    })
 
 
 # Export the FastMCP app for use in other modules and server runners

{mcp_sqlite_memory_bank-1.3.1.dist-info → mcp_sqlite_memory_bank-1.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp_sqlite_memory_bank
-Version: 1.3.1
+Version: 1.4.2
 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
@@ -40,10 +40,14 @@ This project provides a robust, discoverable API for creating, exploring, and ma
 - Build and query knowledge graphs for semantic search and reasoning
 - Store, retrieve, and organize notes or structured data for LLM agents
 - Enable natural language workflows for database management and exploration
+- Intelligent content discovery with semantic search capabilities
+- Access memory content through standardized MCP Resources and Prompts
 - Integrate with FastMCP, Claude Desktop, and other agent platforms for seamless tool discovery
 
 **Why mcp_sqlite_memory_bank?**
-- Explicit, discoverable APIs for LLMs and agents
+- **Full MCP Compliance:** Resources, Prompts, and 20+ organized tools
+- **Semantic Search:** Natural language content discovery with AI-powered similarity matching
+- **Explicit, discoverable APIs** for LLMs and agents with enhanced categorization
 - Safe, parameterized queries and schema management
 - Designed for extensibility and open source collaboration
 
@@ -108,18 +112,59 @@ Restart your IDE and try asking your AI assistant:
 - **Dynamic Table Management:** Create, list, describe, rename, and drop tables at runtime
 - **CRUD Operations:** Insert, read, update, and delete rows in any table
 - **Safe SQL:** Run parameterized SELECT queries with input validation
+- **Semantic Search:** Natural language search using sentence-transformers for intelligent content discovery
+- **MCP Resources:** Access memory content through standardized MCP resource URIs
+- **MCP Prompts:** Built-in intelligent prompts for common memory analysis workflows
+- **Tool Categorization:** Organized tool discovery with detailed usage examples for enhanced LLM integration
 - **Knowledge Graph Tools:** Built-in support for node/edge schemas and property graphs
 - **Agent/LLM Integration:** Explicit, tool-based APIs for easy discovery and automation
 - **Open Source:** MIT licensed, fully tested, and ready for community use
 
 ---
 
+## MCP Compliance & Enhanced Integration
+
+SQLite Memory Bank v1.4.0+ provides full Model Context Protocol (MCP) compliance with advanced features for enhanced LLM and agent integration:
+
+### 🔧 MCP Tools (20 Available)
+Organized into logical categories for easy discovery:
+- **Schema Management** (6 tools): Table creation, modification, and inspection
+- **Data Operations** (5 tools): CRUD operations with validation
+- **Search & Discovery** (2 tools): Content search and exploration
+- **Semantic Search** (5 tools): AI-powered natural language content discovery
+- **Analytics** (2 tools): Memory bank insights and statistics
+
+### 📄 MCP Resources (5 Available)
+Real-time access to memory content via standardized URIs:
+- `memory://tables/list` - List of all available tables
+- `memory://tables/{table_name}/schema` - Table schema information
+- `memory://tables/{table_name}/data` - Table data content
+- `memory://search/{query}` - Search results as resources
+- `memory://analytics/overview` - Memory bank overview analytics
+
+### 💡 MCP Prompts (4 Available)
+Intelligent prompts for common memory analysis workflows:
+- `analyze-memory-content` - Analyze memory bank content and provide insights
+- `search-and-summarize` - Search and create summary prompts
+- `technical-decision-analysis` - Analyze technical decisions from memory
+- `memory-bank-context` - Provide memory bank context for AI conversations
+
+### 🎯 Enhanced Discoverability
+- **Tool Categorization:** `list_tool_categories()` for organized tool discovery
+- **Usage Examples:** `get_tools_by_category()` with detailed examples for each tool
+- **Semantic Search:** Natural language queries for intelligent content discovery
+- **LLM-Friendly APIs:** Explicit, descriptive tool names and comprehensive documentation
+
+---
+
 
 ## Tools & API Reference
 
 All tools are designed for explicit, discoverable use by LLMs, agents, and developers. Each function is available as a direct Python import and as an MCP tool.
 
-### Table Management Tools
+**🔍 Tool Discovery:** Use `list_tool_categories()` to see all organized tool categories, or `get_tools_by_category(category)` for detailed information about specific tool groups with usage examples.
+
+### Schema Management Tools (6 tools)
 
 | Tool | Description | Required Parameters | Optional Parameters |
 |------|-------------|---------------------|---------------------|
@@ -130,7 +175,7 @@ All tools are designed for explicit, discoverable use by LLMs, agents, and devel
 | `describe_table` | Get schema details | `table_name` (str) | None |
 | `list_all_columns` | List all columns for all tables | None | None |
 
-### Data Management Tools
+### Data Operations Tools (5 tools)
 
 | Tool | Description | Required Parameters | Optional Parameters |
 |------|-------------|---------------------|---------------------|
@@ -140,6 +185,30 @@ All tools are designed for explicit, discoverable use by LLMs, agents, and devel
 | `delete_rows` | Delete rows from table | `table_name` (str), `where` (dict) | None |
 | `run_select_query` | Run safe SELECT query | `table_name` (str) | `columns` (list[str]), `where` (dict), `limit` (int) |
 
+### Search & Discovery Tools (2 tools)
+
+| Tool | Description | Required Parameters | Optional Parameters |
+|------|-------------|---------------------|---------------------|
+| `search_content` | Full-text search across table content | `query` (str) | `tables` (list[str]), `limit` (int) |
+| `explore_tables` | Explore and discover table structures | None | `pattern` (str), `include_row_counts` (bool) |
+
+### Semantic Search Tools (5 tools)
+
+| Tool | Description | Required Parameters | Optional Parameters |
+|------|-------------|---------------------|---------------------|
+| `add_embeddings` | Generate vector embeddings for semantic search | `table_name` (str), `text_columns` (list[str]) | `embedding_column` (str), `model_name` (str) |
+| `semantic_search` | Natural language search using vector similarity | `query` (str) | `tables` (list[str]), `similarity_threshold` (float), `limit` (int) |
+| `find_related` | Find content related to specific row by similarity | `table_name` (str), `row_id` (int) | `similarity_threshold` (float), `limit` (int) |
+| `smart_search` | Hybrid keyword + semantic search | `query` (str) | `tables` (list[str]), `semantic_weight` (float), `text_weight` (float) |
+| `embedding_stats` | Get statistics about semantic search readiness | `table_name` (str) | `embedding_column` (str) |
+
+### Tool Discovery & Organization (2 tools)
+
+| Tool | Description | Required Parameters | Optional Parameters |
+|------|-------------|---------------------|---------------------|
+| `list_tool_categories` | List all available tool categories | None | None |
+| `get_tools_by_category` | Get detailed tool information by category | `category` (str) | None |
+
 Each tool validates inputs and returns consistent response formats with success/error indicators and appropriate data payloads.
 
 ---
@@ -468,6 +537,97 @@ For a complete agent memory implementation example, see [examples/agent_memory_e
 
 ---
 
+## MCP Resources and Prompts Usage
+
+### Using MCP Resources
+
+MCP Resources provide real-time access to memory content through standardized URIs:
+
+```python
+# Access resource via MCP client
+resource_uri = "memory://tables/list"
+tables_resource = await client.read_resource(resource_uri)
+
+# Get table schema
+schema_uri = "memory://tables/user_preferences/schema"
+schema_resource = await client.read_resource(schema_uri)
+
+# Access table data
+data_uri = "memory://tables/user_preferences/data"
+data_resource = await client.read_resource(data_uri)
+
+# Search as resource
+search_uri = "memory://search/user preferences coding style"
+search_resource = await client.read_resource(search_uri)
+
+# Analytics overview
+analytics_uri = "memory://analytics/overview"
+analytics_resource = await client.read_resource(analytics_uri)
+```
+
+### Using MCP Prompts
+
+MCP Prompts provide intelligent analysis workflows:
+
+```python
+# Analyze memory content
+analysis_prompt = await client.get_prompt("analyze-memory-content", {
+    "focus_area": "technical_decisions"
+})
+
+# Search and summarize
+summary_prompt = await client.get_prompt("search-and-summarize", {
+    "query": "database performance optimization",
+    "max_results": 10
+})
+
+# Technical decision analysis
+decision_analysis = await client.get_prompt("technical-decision-analysis", {
+    "decision_category": "architecture"
+})
+
+# Get memory context for conversations
+context_prompt = await client.get_prompt("memory-bank-context", {
+    "conversation_topic": "API design patterns"
+})
+```
+
+### Semantic Search Examples
+
+```python
+# Enable semantic search on existing table
+add_embeddings("technical_decisions", ["decision_name", "rationale"])
+
+# Natural language search
+results = semantic_search("machine learning algorithms", 
+                         similarity_threshold=0.4, 
+                         limit=5)
+
+# Find related content
+related = find_related("technical_decisions", 
+                      row_id=123, 
+                      similarity_threshold=0.5)
+
+# Hybrid search (keyword + semantic)
+hybrid_results = smart_search("API design patterns",
+                             semantic_weight=0.7,
+                             text_weight=0.3)
+```
+
+### Tool Organization Discovery
+
+```python
+# Discover tool categories
+categories = list_tool_categories()
+# Returns: {"schema_management": 6, "data_operations": 5, ...}
+
+# Get detailed tool information
+schema_tools = get_tools_by_category("schema_management")
+# Returns detailed info with usage examples for each tool
+```
+
+---
+
 ## Troubleshooting
 
 ### Common MCP Connection Issues

mcp_sqlite_memory_bank-1.4.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+mcp_sqlite_memory_bank/__init__.py,sha256=6Y9_iSiQIWOPJYMcMkbrqmaWiM-ymRHdNR6W-8jHj-k,2403
+mcp_sqlite_memory_bank/database.py,sha256=dQdl3QPqBBf_AQwMXHjRZ8rdget0UKQ2vz0V-Ik1o7g,42231
+mcp_sqlite_memory_bank/prompts.py,sha256=nLY6rf08wU5TeSLoSxjTlwcU_OIiJeOIkJYDQM_PFpo,11762
+mcp_sqlite_memory_bank/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_sqlite_memory_bank/resources.py,sha256=A55G44MIQdNiYlOa9fJqGVC7OL_Cx7sbE8oCF4JlnX8,7464
+mcp_sqlite_memory_bank/semantic.py,sha256=wvabBqlThNN76feyEa8BNRachBZYxkZQaPPIweHgxV8,14855
+mcp_sqlite_memory_bank/server.py,sha256=x4cHGEheG6XY54ErHjtRaPPsDjbQUdvmWZPgipKk7rU,48096
+mcp_sqlite_memory_bank/types.py,sha256=2rNhd6dbvEFsey9QGHQ0VPGSB3U0RaXw8fKVfiBuUJw,6535
+mcp_sqlite_memory_bank/utils.py,sha256=wHbR0cUlV-AWBk8ToI5ZgCrfrMp380ofyEc_GLB0l4g,6185
+mcp_sqlite_memory_bank-1.4.2.dist-info/licenses/LICENSE,sha256=KPr7eFgCJqQIjeSAcwRafbjcgm-10zkrJ7MFoTOGJQg,1092
+mcp_sqlite_memory_bank-1.4.2.dist-info/METADATA,sha256=D52NnWZDvyA9lVqgM-YZaev8X3lfAeQdo2udl3GHj_k,33094
+mcp_sqlite_memory_bank-1.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_sqlite_memory_bank-1.4.2.dist-info/entry_points.txt,sha256=S9yGWiCe8f_rgcGCgbwEAX2FfJ9jXWxcc4K4Jenbcn8,150
+mcp_sqlite_memory_bank-1.4.2.dist-info/top_level.txt,sha256=xQ8MTGECpWMR-9DV4H8mMqaSoZqE-C8EvpOg9E2U1wM,23
+mcp_sqlite_memory_bank-1.4.2.dist-info/RECORD,,

mcp_sqlite_memory_bank-1.3.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-mcp_sqlite_memory_bank/__init__.py,sha256=6Y9_iSiQIWOPJYMcMkbrqmaWiM-ymRHdNR6W-8jHj-k,2403
-mcp_sqlite_memory_bank/database.py,sha256=kBHiibDV2ucm9alaDrNB-txm7v-hGt-uTNHIFKuFlKI,41873
-mcp_sqlite_memory_bank/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_sqlite_memory_bank/semantic.py,sha256=XVfM1C95TdZDtXOrwrGxR5JZnmeeO4O45gxniPWa6go,14791
-mcp_sqlite_memory_bank/server.py,sha256=lt_1LSXDDJoSATNd4T07GmfPqlYcdQlmwDGR_TySboM,33896
-mcp_sqlite_memory_bank/types.py,sha256=2rNhd6dbvEFsey9QGHQ0VPGSB3U0RaXw8fKVfiBuUJw,6535
-mcp_sqlite_memory_bank/utils.py,sha256=wHbR0cUlV-AWBk8ToI5ZgCrfrMp380ofyEc_GLB0l4g,6185
-mcp_sqlite_memory_bank-1.3.1.dist-info/licenses/LICENSE,sha256=KPr7eFgCJqQIjeSAcwRafbjcgm-10zkrJ7MFoTOGJQg,1092
-mcp_sqlite_memory_bank-1.3.1.dist-info/METADATA,sha256=xgs7hG0Uu1Sr6Qpj_HR6wHz48P4wxTQmD_CbSknsLus,26002
-mcp_sqlite_memory_bank-1.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_sqlite_memory_bank-1.3.1.dist-info/entry_points.txt,sha256=S9yGWiCe8f_rgcGCgbwEAX2FfJ9jXWxcc4K4Jenbcn8,150
-mcp_sqlite_memory_bank-1.3.1.dist-info/top_level.txt,sha256=xQ8MTGECpWMR-9DV4H8mMqaSoZqE-C8EvpOg9E2U1wM,23
-mcp_sqlite_memory_bank-1.3.1.dist-info/RECORD,,