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

mcp_sqlite_memory_bank/tools/search.py

@@ -0,0 +1,380 @@
+"""
+Search tools module for SQLite Memory Bank.
+
+This module contains all search-related MCP tools including content search,
+semantic search, embedding management, and intelligent search capabilities.
+"""
+
+import logging
+import traceback
+from typing import Any, Dict, List, Optional, cast
+
+from ..database import get_database
+from ..types import MemoryBankError, DatabaseError, ToolResponse
+from ..utils import catch_errors
+from ..semantic import is_semantic_search_available
+
+
+@catch_errors
+def search_content(
+    query: str,
+    tables: Optional[List[str]] = None,
+    limit: int = 50,
+) -> ToolResponse:
+    """Perform full-text search across table content using natural language queries."""
+    from .. import server
+    return cast(ToolResponse, get_database(server.DB_PATH).search_content(query, tables, limit))
+
+
+@catch_errors
+def explore_tables(
+    pattern: Optional[str] = None,
+    include_row_counts: bool = True,
+) -> ToolResponse:
+    """Explore and discover table structures and content for better searchability."""
+    from .. import server
+    return cast(ToolResponse, get_database(server.DB_PATH).explore_tables(pattern, include_row_counts))
+
+
+@catch_errors
+def add_embeddings(
+    table_name: str,
+    text_columns: List[str],
+    embedding_column: str = "embedding",
+    model_name: str = "all-MiniLM-L6-v2",
+) -> ToolResponse:
+    """Generate and store vector embeddings for semantic search on table content."""
+    from .. import server
+    return cast(ToolResponse, get_database(server.DB_PATH).generate_embeddings(
+        table_name, text_columns, embedding_column, model_name
+    ))
+
+
+@catch_errors
+def 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:
+    """Find content using natural language semantic similarity rather than exact keyword matching."""
+    from .. import server
+    return cast(ToolResponse, get_database(server.DB_PATH).semantic_search(
+        query, tables, "embedding", None, similarity_threshold, limit, model_name
+    ))
+
+
+@catch_errors
+def find_related(
+    table_name: str,
+    row_id: int,
+    similarity_threshold: float = 0.5,
+    limit: int = 5,
+    model_name: str = "all-MiniLM-L6-v2",
+) -> ToolResponse:
+    """Find content related to a specific row by semantic similarity."""
+    from .. import server
+    return cast(ToolResponse, get_database(server.DB_PATH).find_related_content(
+        table_name, row_id, "embedding", similarity_threshold, limit, model_name
+    ))
+
+
+@catch_errors
+def 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:
+    """Intelligent hybrid search combining semantic understanding with keyword matching."""
+    from .. import server
+    return cast(ToolResponse, get_database(server.DB_PATH).hybrid_search(
+        query, tables, None, "embedding", semantic_weight, text_weight, limit, model_name
+    ))
+
+
+@catch_errors
+def embedding_stats(
+    table_name: str,
+    embedding_column: str = "embedding",
+) -> ToolResponse:
+    """Get statistics about semantic search readiness for a table."""
+    from .. import server
+    return cast(ToolResponse, get_database(server.DB_PATH).get_embedding_stats(table_name, embedding_column))
+
+
+@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:
+        from .. import server
+        db = get_database(server.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}
+        })
+
+
+@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:
+        from .. import server
+        db = get_database(server.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 using the same pattern as smart_search
+        try:
+            hybrid_result = get_database(server.DB_PATH).hybrid_search(
+                query, search_tables, None, "embedding", semantic_weight, text_weight, limit, model_name
+            )
+        except Exception as search_error:
+            # If hybrid search fails, fall back to regular content search
+            logging.warning(f"Hybrid search failed, falling back to content search: {search_error}")
+            try:
+                fallback_result = get_database(server.DB_PATH).search_content(query, search_tables, limit)
+                if fallback_result.get("success"):
+                    # Create a new dictionary to avoid type issues
+                    enhanced_fallback = dict(fallback_result)
+                    enhanced_fallback["search_type"] = "text_fallback"
+                    enhanced_fallback["auto_embedded_tables"] = auto_embedded_tables
+                    enhanced_fallback["fallback_reason"] = str(search_error)
+                    return cast(ToolResponse, enhanced_fallback)
+            except Exception as fallback_error:
+                return cast(ToolResponse, {
+                    "success": False,
+                    "error": f"Both hybrid and fallback search failed. Hybrid: {search_error}, Fallback: {fallback_error}",
+                    "category": "HYBRID_SEARCH_ERROR",
+                    "details": {"query": query, "tables": tables}
+                })
+            
+            # If we get here, both searches failed
+            return cast(ToolResponse, {
+                "success": False,
+                "error": f"Hybrid search failed: {search_error}",
+                "category": "HYBRID_SEARCH_ERROR",
+                "details": {"query": query, "tables": tables}
+            })
+        
+        # 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:
+        # Add detailed error information for debugging
+        error_details = {
+            "query": query, 
+            "tables": tables,
+            "error_type": type(e).__name__,
+            "error_str": str(e),
+            "traceback": traceback.format_exc()
+        }
+        return cast(ToolResponse, {
+            "success": False,
+            "error": f"Auto smart search failed: {str(e)}",
+            "category": "HYBRID_SEARCH_ERROR",
+            "details": error_details
+        })

mcp_sqlite_memory_bank/utils.py

@@ -9,6 +9,9 @@ import re
 import os
 import sqlite3
 import logging
+import sys
+import traceback
+from datetime import datetime
 from functools import wraps
 from typing import Any, Callable, Dict, List, TypeVar, cast, Union, Tuple
 from .types import ValidationError, DatabaseError, SchemaError, MemoryBankError, ToolResponse
@@ -174,3 +177,189 @@ def build_where_clause(where: Dict[str, Any], valid_columns: List[str]) -> Union
     except Exception as e:
         logging.error(f"Error in build_where_clause: {e}")
         return {"success": False, "error": f"Error building WHERE clause: {e}"}
+
+
+def suggest_recovery(error: Exception, function_name: str) -> Dict[str, Any]:
+    """
+    Suggest recovery actions based on the error type and context.
+
+    Args:
+        error: The exception that occurred
+        function_name: Name of the function where error occurred
+
+    Returns:
+        Dictionary with recovery suggestions
+    """
+    suggestions = {
+        "auto_recovery_available": False,
+        "manual_steps": [],
+        "documentation_links": [],
+        "similar_errors": []
+    }
+
+    error_str = str(error).lower()
+    error_type = type(error).__name__
+
+    # Dependency-related errors
+    if "sentence-transformers" in error_str or "transformers" in error_str:
+        suggestions.update({
+            "auto_recovery_available": True,
+            "install_command": "pip install sentence-transformers",
+            "manual_steps": [
+                "Install sentence-transformers: pip install sentence-transformers",
+                "Restart the MCP server",
+                "Try the semantic search operation again"
+            ],
+            "explanation": "Semantic search requires the sentence-transformers library",
+            "fallback_available": "Keyword search is available as fallback"
+        })
+
+    # Database errors
+    elif "database" in error_str or "sqlite" in error_str:
+        suggestions.update({
+            "manual_steps": [
+                "Check if database file exists and is writable",
+                "Verify disk space is available",
+                "Check if another process is using the database",
+                "Try creating a new database file"
+            ],
+            "auto_recovery_available": False,
+            "diagnostics": {
+                "check_db_path": "Verify DB_PATH environment variable",
+                "check_permissions": "Ensure write permissions to database directory"
+            }
+        })
+
+    # Table/schema errors
+    elif "table" in error_str and ("not exist" in error_str or "missing" in error_str):
+        suggestions.update({
+            "auto_recovery_available": True,
+            "manual_steps": [
+                "List available tables with list_tables()",
+                "Check table name spelling",
+                "Create the table if it doesn't exist",
+                "Refresh your table list"
+            ],
+            "next_actions": ["call list_tables() to see available tables"]
+        })
+
+    # Column errors
+    elif "column" in error_str and ("not exist" in error_str or "invalid" in error_str):
+        suggestions.update({
+            "auto_recovery_available": True,
+            "manual_steps": [
+                "Use describe_table() to see available columns",
+                "Check column name spelling and case",
+                "Verify the column exists in the table schema"
+            ],
+            "next_actions": ["call describe_table() to see column schema"]
+        })
+
+    # Import/module errors
+    elif "import" in error_str or "module" in error_str:
+        suggestions.update({
+            "manual_steps": [
+                "Check if required packages are installed",
+                "Verify Python environment is correct",
+                "Try reinstalling the package",
+                "Check for version compatibility issues"
+            ],
+            "diagnostics": {
+                "python_version": sys.version,
+                "check_packages": "pip list | grep -E '(torch|transformers|sentence)'"
+            }
+        })
+
+    # Function/method errors (like our recent 'FunctionTool' issue)
+    elif "not callable" in error_str or "has no attribute" in error_str:
+        suggestions.update({
+            "manual_steps": [
+                "Check if you're using the correct function/method name",
+                "Verify the object type is what you expect",
+                "Check for import issues or namespace conflicts",
+                "Try restarting the MCP server"
+            ],
+            "diagnostics": {
+                "object_type": "Check the actual type of the object being called",
+                "namespace_check": "Verify imports and module loading"
+            },
+            "likely_causes": [
+                "Using PyPI version instead of local development code",
+                "Import conflicts between different module versions",
+                "Object not properly initialized"
+            ]
+        })
+
+    # Add context-specific suggestions
+    if function_name.startswith("semantic") or function_name.startswith("embedding"):
+        suggestions["context_help"] = {
+            "semantic_search_help": "Semantic search requires sentence-transformers and embeddings to be generated",
+            "embedding_help": "Use add_embeddings() and generate_embeddings() before semantic search",
+            "fallback_option": "Consider using search_content() for keyword-based search"
+        }
+
+    return suggestions
+
+
+def enhanced_catch_errors(include_traceback: bool = False, auto_recovery: bool = True):
+    """
+    Enhanced error decorator with debugging context and auto-recovery suggestions.
+
+    Args:
+        include_traceback: Whether to include full traceback in error details
+        auto_recovery: Whether to include auto-recovery suggestions
+    """
+    def decorator(f: T) -> T:
+        @wraps(f)
+        def wrapper(*args: Any, **kwargs: Any) -> ToolResponse:
+            try:
+                return f(*args, **kwargs)
+            except Exception as e:
+                # Enhanced error context
+                error_context = {
+                    "function": f.__name__,
+                    "timestamp": datetime.now().isoformat(),
+                    "args_preview": str(args)[:200],  # Truncate for safety
+                    "kwargs_preview": {k: str(v)[:100] for k, v in kwargs.items()},
+                    "python_version": sys.version,
+                    "error_type": type(e).__name__
+                }
+
+                # Add traceback if requested
+                if include_traceback:
+                    error_context["traceback"] = traceback.format_exc()
+
+                # Auto-recovery suggestions
+                recovery_suggestions = {}
+                if auto_recovery:
+                    recovery_suggestions = suggest_recovery(e, f.__name__)
+
+                # Determine error category
+                if isinstance(e, MemoryBankError):
+                    category = e.category.name if hasattr(e, 'category') else "MEMORY_BANK"
+                    return cast(ToolResponse, {
+                        "success": False,
+                        "error": str(e),
+                        "category": category,
+                        "details": error_context,
+                        "recovery": recovery_suggestions
+                    })
+                elif isinstance(e, sqlite3.Error):
+                    return cast(ToolResponse, {
+                        "success": False,
+                        "error": f"Database error: {str(e)}",
+                        "category": "DATABASE",
+                        "details": error_context,
+                        "recovery": recovery_suggestions
+                    })
+                else:
+                    return cast(ToolResponse, {
+                        "success": False,
+                        "error": f"Unexpected error: {str(e)}",
+                        "category": "SYSTEM",
+                        "details": error_context,
+                        "recovery": recovery_suggestions
+                    })
+
+        return cast(T, wrapper)
+    return decorator

{mcp_sqlite_memory_bank-1.4.3.dist-info → mcp_sqlite_memory_bank-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp_sqlite_memory_bank
-Version: 1.4.3
+Version: 1.5.1
 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.5.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+mcp_sqlite_memory_bank/__init__.py,sha256=XHBjR2IbhTdlXtGCCUSM-4M1y-SIVTMIVx3iQXWSd14,2796
+mcp_sqlite_memory_bank/__main__.py,sha256=MkEV9A5JNAi4Pt5zbKM0qguPN5v8a0GXSS0OqXeDzVM,2040
+mcp_sqlite_memory_bank/database.py,sha256=E-GZ150XWgimgAi3LbATz2WlrzhOd1OcMhkuQip3BkI,46489
+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=ozk0GYTwDxITWrUiOE735hn1v17kf8lJwIe9V1o2fb8,21680
+mcp_sqlite_memory_bank/semantic.py,sha256=LTZWBnENx6G1QGqppMLanikAC_bXGjEMB79ojU6rjDg,15349
+mcp_sqlite_memory_bank/server.py,sha256=YC4n_0yXrToLquCZE6iyLp_AdQUzCCNixYZm384fQno,43710
+mcp_sqlite_memory_bank/types.py,sha256=Lr6RVUUrdDdHUod6IvxLFaWg3H2uezL9luL8pYKxahM,6692
+mcp_sqlite_memory_bank/utils.py,sha256=1sNMlqpauqezDMd4uvjl_31qANm4K9C6HP4pGWo1Pxg,13963
+mcp_sqlite_memory_bank/tools/__init__.py,sha256=hLOaeSndOAmeXGPYZmdwpnPEwE8nCqKKAaDWFENDsyE,1807
+mcp_sqlite_memory_bank/tools/analytics.py,sha256=iTWZ5CVUiw3itdwvY8XEjnw8uwEYInO11LnVQU1UBas,19470
+mcp_sqlite_memory_bank/tools/basic.py,sha256=6wB6r_n67WLWYGTHlpgUfTT7uFZPeAFJOX3Ly0flgyg,3604
+mcp_sqlite_memory_bank/tools/discovery.py,sha256=pHwM0P2ffef3_MHFIehnWHRWzWz0vNGI8wZDN9IgVwg,53327
+mcp_sqlite_memory_bank/tools/search.py,sha256=SZhxtP0t_dUr3ttIEl6CDUFcdKESVcPQSBeCpBDD250,16176
+mcp_sqlite_memory_bank-1.5.1.dist-info/licenses/LICENSE,sha256=KPr7eFgCJqQIjeSAcwRafbjcgm-10zkrJ7MFoTOGJQg,1092
+mcp_sqlite_memory_bank-1.5.1.dist-info/METADATA,sha256=rrGClHtmpAGrRD2fXJOa917MjGGx4dlRvPWsc27DiF4,33094
+mcp_sqlite_memory_bank-1.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_sqlite_memory_bank-1.5.1.dist-info/entry_points.txt,sha256=S9yGWiCe8f_rgcGCgbwEAX2FfJ9jXWxcc4K4Jenbcn8,150
+mcp_sqlite_memory_bank-1.5.1.dist-info/top_level.txt,sha256=xQ8MTGECpWMR-9DV4H8mMqaSoZqE-C8EvpOg9E2U1wM,23
+mcp_sqlite_memory_bank-1.5.1.dist-info/RECORD,,

mcp_sqlite_memory_bank-1.4.3.dist-info/RECORD

@@ -1,15 +0,0 @@
-mcp_sqlite_memory_bank/__init__.py,sha256=6Y9_iSiQIWOPJYMcMkbrqmaWiM-ymRHdNR6W-8jHj-k,2403
-mcp_sqlite_memory_bank/database.py,sha256=cL60QMCVUO0fNqeMk0_PvKCQXfNTcl04-1jQX0TIK90,43000
-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=MM0Cgjx8sLpKrpGj0nBUHZRy-I_g9TN6cGYDNuzaPkI,51775
-mcp_sqlite_memory_bank/types.py,sha256=Lr6RVUUrdDdHUod6IvxLFaWg3H2uezL9luL8pYKxahM,6692
-mcp_sqlite_memory_bank/utils.py,sha256=wHbR0cUlV-AWBk8ToI5ZgCrfrMp380ofyEc_GLB0l4g,6185
-mcp_sqlite_memory_bank-1.4.3.dist-info/licenses/LICENSE,sha256=KPr7eFgCJqQIjeSAcwRafbjcgm-10zkrJ7MFoTOGJQg,1092
-mcp_sqlite_memory_bank-1.4.3.dist-info/METADATA,sha256=j_nVJdXKzIRkMWg5VMm7YfD6DI_1Fok-UYEkowxIy4o,33094
-mcp_sqlite_memory_bank-1.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_sqlite_memory_bank-1.4.3.dist-info/entry_points.txt,sha256=S9yGWiCe8f_rgcGCgbwEAX2FfJ9jXWxcc4K4Jenbcn8,150
-mcp_sqlite_memory_bank-1.4.3.dist-info/top_level.txt,sha256=xQ8MTGECpWMR-9DV4H8mMqaSoZqE-C8EvpOg9E2U1wM,23
-mcp_sqlite_memory_bank-1.4.3.dist-info/RECORD,,