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

mcp_sqlite_memory_bank/utils.py

@@ -14,7 +14,13 @@ 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
+from .types import (
+    ValidationError,
+    DatabaseError,
+    SchemaError,
+    MemoryBankError,
+    ToolResponse,
+)
 
 T = TypeVar("T", bound=Callable[..., ToolResponse])
 
@@ -35,11 +41,17 @@ def catch_errors(f: T) -> T:
         except sqlite3.Error as e:
             logging.error(f"{f.__name__} database error: {e}")
             return cast(
-                ToolResponse, DatabaseError(f"Database error in {f.__name__}: {e}", {"sqlite_error": str(e)}).to_dict()
+                ToolResponse,
+                DatabaseError(
+                    f"Database error in {f.__name__}: {e}", {"sqlite_error": str(e)}
+                ).to_dict(),
             )
         except Exception as e:
             logging.error(f"Unexpected error in {f.__name__}: {e}")
-            return cast(ToolResponse, DatabaseError(f"Unexpected error in {f.__name__}: {e}").to_dict())
+            return cast(
+                ToolResponse,
+                DatabaseError(f"Unexpected error in {f.__name__}: {e}").to_dict(),
+            )
 
     return cast(T, wrapper)
 
@@ -70,7 +82,9 @@ def validate_column_definition(column: Dict[str, Any]) -> None:
         column: Dictionary with column definition (must have 'name' and 'type' keys)
     """
     if not isinstance(column, dict):
-        raise ValidationError("Column definition must be a dictionary", {"received": str(type(column))})
+        raise ValidationError(
+            "Column definition must be a dictionary", {"received": str(type(column))}
+        )
     if "name" not in column or "type" not in column:
         raise ValidationError(
             "Column definition must have 'name' and 'type' keys",
@@ -118,9 +132,15 @@ def get_table_columns_by_name(table_name: str) -> Union[List[str], Dict[str, Any
         validate_identifier(table_name, "table name")
         with sqlite3.connect(os.environ.get("DB_PATH", "./test.db")) as conn:
             cur = conn.cursor()
-            cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+            cur.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+                (table_name,),
+            )
             if not cur.fetchone():
-                return {"success": False, "error": f"Table '{table_name}' does not exist"}
+                return {
+                    "success": False,
+                    "error": f"Table '{table_name}' does not exist",
+                }
 
             # Get column information
             cur.execute(f"PRAGMA table_info({table_name})")
@@ -147,7 +167,9 @@ def validate_table_exists(conn: sqlite3.Connection, table_name: str) -> None:
         raise SchemaError(f"Table does not exist: {table_name}", {"table_name": table_name})
 
 
-def build_where_clause(where: Dict[str, Any], valid_columns: List[str]) -> Union[Tuple[str, list], Dict[str, Any]]:
+def build_where_clause(
+    where: Dict[str, Any], valid_columns: List[str]
+) -> Union[Tuple[str, List[Any]], Dict[str, Any]]:
     """
     Build a WHERE clause from a dictionary of column-value pairs.
 
@@ -168,7 +190,10 @@ def build_where_clause(where: Dict[str, Any], valid_columns: List[str]) -> Union
 
         for col, val in where.items():
             if col not in valid_columns:
-                return {"success": False, "error": f"Invalid column in where clause: {col}"}
+                return {
+                    "success": False,
+                    "error": f"Invalid column in where clause: {col}",
+                }
             conditions.append(f"{col}=?")
             values.append(val)
 
@@ -194,114 +219,127 @@ def suggest_recovery(error: Exception, function_name: str) -> Dict[str, Any]:
         "auto_recovery_available": False,
         "manual_steps": [],
         "documentation_links": [],
-        "similar_errors": []
+        "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"
-        })
+        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"
+        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"]
-        })
+        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"]
-        })
+        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)'"
+        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"
-            ]
-        })
+        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"
+            "fallback_option": "Consider using search_content() for keyword-based search",
         }
 
     return suggestions
 
 
-def enhanced_catch_errors(include_traceback: bool = False, auto_recovery: bool = True):
+def enhanced_catch_errors(
+    include_traceback: bool = False, auto_recovery: bool = True
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     """
     Enhanced error decorator with debugging context and auto-recovery suggestions.
 
@@ -309,6 +347,7 @@ def enhanced_catch_errors(include_traceback: bool = False, auto_recovery: bool =
         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:
@@ -322,7 +361,7 @@ def enhanced_catch_errors(include_traceback: bool = False, auto_recovery: bool =
                     "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__
+                    "error_type": type(e).__name__,
                 }
 
                 # Add traceback if requested
@@ -336,30 +375,40 @@ def enhanced_catch_errors(include_traceback: bool = False, auto_recovery: bool =
 
                 # 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
-                    })
+                    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
-                    })
+                    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(
+                        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.5.1.dist-info → mcp_sqlite_memory_bank-1.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp_sqlite_memory_bank
-Version: 1.5.1
+Version: 1.6.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
@@ -9,13 +9,13 @@ Project-URL: Source, https://github.com/robertmeisner/mcp_sqlite_memory_bank
 Project-URL: Issues, https://github.com/robertmeisner/mcp_sqlite_memory_bank/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: uvicorn>=0.22.0
 Requires-Dist: pydantic>=1.10.0
-Requires-Dist: fastmcp
+Requires-Dist: fastmcp>=2.9.0
 Requires-Dist: sqlalchemy>=2.0.0
 Requires-Dist: sentence-transformers>=2.2.0
 Requires-Dist: torch>=1.9.0
@@ -126,10 +126,10 @@ Restart your IDE and try asking your AI assistant:
 
 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)
+### 🔧 MCP Tools (23 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
+- **Data Operations** (8 tools): CRUD operations with validation and batch processing
 - **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
@@ -175,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 Operations Tools (5 tools)
+### Data Operations Tools (8 tools)
 
 | Tool | Description | Required Parameters | Optional Parameters |
 |------|-------------|---------------------|---------------------|
@@ -184,6 +184,9 @@ All tools are designed for explicit, discoverable use by LLMs, agents, and devel
 | `update_rows` | Update existing rows | `table_name` (str), `data` (dict), `where` (dict) | None |
 | `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) |
+| `upsert_memory` | Smart update or create memory record | `table_name` (str), `data` (dict), `match_columns` (list[str]) | None |
+| `batch_create_memories` | Efficiently create multiple memory records | `table_name` (str), `data_list` (list[dict]) | `match_columns` (list[str]), `use_upsert` (bool) |
+| `batch_delete_memories` | Delete multiple memory records efficiently | `table_name` (str), `conditions_list` (list[dict]) | `match_mode` (str) |
 
 ### Search & Discovery Tools (2 tools)
 
@@ -211,6 +214,51 @@ All tools are designed for explicit, discoverable use by LLMs, agents, and devel
 
 Each tool validates inputs and returns consistent response formats with success/error indicators and appropriate data payloads.
 
+## 🚀 Batch Operations & Smart Memory Management
+
+SQLite Memory Bank provides powerful batch operations for efficient memory management:
+
+### Smart Memory Updates
+- **`upsert_memory`**: Intelligent update-or-create for preventing duplicates
+- **Duplicate Prevention**: Uses match columns to find existing records
+- **Flexible Matching**: Specify which columns to match for finding existing records
+
+### Efficient Batch Processing
+- **`batch_create_memories`**: Create multiple records in a single operation
+- **Smart vs Fast Modes**: Choose between upsert logic (prevents duplicates) or fast insertion
+- **Partial Success Handling**: Continues processing even if some records fail
+- **Detailed Feedback**: Returns counts for created, updated, and failed records
+
+### Flexible Batch Deletion
+- **`batch_delete_memories`**: Delete multiple records with complex conditions
+- **Flexible Matching**: Support for OR (match_any) and AND (match_all) logic
+- **Condition Lists**: Delete based on multiple different criteria
+- **Safe Operations**: Validates conditions before deletion
+
+### Usage Examples
+
+```python
+# Smart memory upsert - prevents duplicates
+upsert_memory('technical_decisions', {
+    'decision_name': 'API Design',
+    'chosen_approach': 'REST APIs',
+    'rationale': 'Better discoverability for LLMs'
+}, match_columns=['decision_name'])
+
+# Batch create with duplicate prevention
+batch_create_memories('project_insights', [
+    {'category': 'performance', 'insight': 'Database indexing'},
+    {'category': 'security', 'insight': 'Input validation'},
+    {'category': 'architecture', 'insight': 'Microservice patterns'}
+], match_columns=['category', 'insight'], use_upsert=True)
+
+# Batch delete with flexible conditions
+batch_delete_memories('old_notes', [
+    {'status': 'archived'},
+    {'created_date': '2023-01-01', 'priority': 'low'}
+], match_mode='match_any')  # Delete if ANY condition matches
+```
+
 ---
 
 ## Transport Modes

mcp_sqlite_memory_bank-1.6.2.dist-info/RECORD

@@ -0,0 +1,21 @@
+mcp_sqlite_memory_bank/__init__.py,sha256=nM63WzpIHto4Xc5pEMVW0xuJ4g5K1Y76M2mnPupV0x0,2795
+mcp_sqlite_memory_bank/__main__.py,sha256=tPbJP9vC6V_2lLOGiiHof-katnc0FXcRqcRWk4SstZ0,2014
+mcp_sqlite_memory_bank/database.py,sha256=pxnhtjglDXOHy-DVpzjgsYTRGjHlJ3V3I7MBNrMULfs,49277
+mcp_sqlite_memory_bank/prompts.py,sha256=cZixeyqSirMwCKBfTHJMfYEFh4xzEf6V_M3QFSuTWdM,11769
+mcp_sqlite_memory_bank/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_sqlite_memory_bank/resources.py,sha256=6rZfpPtS5gEu2WIaQJUxgxFsDqgQYcNtkv3kVxFX4jA,22972
+mcp_sqlite_memory_bank/semantic.py,sha256=W71SHC44qpptcCYklR8T2shChtdTHrDb8VlIxMu4PLc,15650
+mcp_sqlite_memory_bank/server.py,sha256=tY_7Uam30NUo-I5VT2LQ-XK3N6JVkAnoIZ5vxvTBxWM,49423
+mcp_sqlite_memory_bank/types.py,sha256=kK8HUz3szwiV9cUJkO56RpnosXEssQT1t0w_166ik5k,6756
+mcp_sqlite_memory_bank/utils.py,sha256=rTJ1PI2uBQw9h7RT4EAcRLYV2HQIuaxFGmqAd1CKRig,15064
+mcp_sqlite_memory_bank/tools/__init__.py,sha256=00TDY78qXLdeaXxcK53xFKlEiY9flHQCuIGnEh5rghg,1786
+mcp_sqlite_memory_bank/tools/analytics.py,sha256=lGvXZbmPR26l96iRibAeZ--O9ykxs05XZZRXefe8MKk,19583
+mcp_sqlite_memory_bank/tools/basic.py,sha256=k_ypt1qfcbekz829uvegydTr9ZkEiuSgwCZUjKRMzs4,19082
+mcp_sqlite_memory_bank/tools/discovery.py,sha256=_Y9dHKSA00qLUodcb80Cm1mmCM5Uh3C-4MCzD_rEoYI,56059
+mcp_sqlite_memory_bank/tools/search.py,sha256=NXBrKsOJD3vaWM0jAc7M9DnI--IveCNEnq-DnfphVhA,16993
+mcp_sqlite_memory_bank-1.6.2.dist-info/licenses/LICENSE,sha256=KPr7eFgCJqQIjeSAcwRafbjcgm-10zkrJ7MFoTOGJQg,1092
+mcp_sqlite_memory_bank-1.6.2.dist-info/METADATA,sha256=X_OWksy928VPc5SmQlXTv3MGpgqrqkxSdD20iwYQX4s,35536
+mcp_sqlite_memory_bank-1.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_sqlite_memory_bank-1.6.2.dist-info/entry_points.txt,sha256=S9yGWiCe8f_rgcGCgbwEAX2FfJ9jXWxcc4K4Jenbcn8,150
+mcp_sqlite_memory_bank-1.6.2.dist-info/top_level.txt,sha256=xQ8MTGECpWMR-9DV4H8mMqaSoZqE-C8EvpOg9E2U1wM,23
+mcp_sqlite_memory_bank-1.6.2.dist-info/RECORD,,

mcp_sqlite_memory_bank-1.5.1.dist-info/RECORD

@@ -1,21 +0,0 @@
-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,,