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

mcp_sqlite_memory_bank/tools/discovery.py

@@ -9,8 +9,7 @@ discovery processes.
 Author: Robert Meisner
 """
 
-import logging
-from typing import Any, Dict, List, Optional, cast, Union
+from typing import Any, Dict, List, Optional, cast
 from datetime import datetime
 
 from ..database import get_database
@@ -112,17 +111,13 @@ def intelligent_discovery(
         # Step 2: Content analysis based on goal
         if discovery_goal in ["understand_content", "find_patterns", "assess_quality"]:
             discovery_session["steps_completed"].append("content_analysis")
-            content_analysis = _analyze_content_for_discovery(
-                db, tables, focus_area, depth
-            )
+            content_analysis = _analyze_content_for_discovery(db, tables, focus_area, depth)
             overview.update(content_analysis)
 
         # Step 3: Schema analysis for structure exploration
         if discovery_goal in ["explore_structure", "understand_content"]:
             discovery_session["steps_completed"].append("schema_analysis")
-            schema_analysis = _analyze_schema_for_discovery(
-                db, tables, focus_area, depth
-            )
+            schema_analysis = _analyze_schema_for_discovery(db, tables, focus_area, depth)
             overview.update(schema_analysis)
 
         # Step 4: Quality assessment
@@ -164,9 +159,7 @@ def intelligent_discovery(
                 },
                 "next_steps": next_steps,
                 "discovery_session": discovery_session,
-                "quick_actions": _generate_quick_actions(
-                    discovery_goal, overview, focus_area
-                ),
+                "quick_actions": _generate_quick_actions(discovery_goal, overview, focus_area),
             },
         )
 
@@ -612,10 +605,7 @@ def discover_relationships(
                     )
 
             # Discover semantic similarity relationships
-            if (
-                "semantic_similarity" in relationship_types
-                and is_semantic_search_available()
-            ):
+            if "semantic_similarity" in relationship_types and is_semantic_search_available():
                 semantic_relationships = _discover_semantic_relationships(
                     db, target_table, all_tables, similarity_threshold
                 )
@@ -638,9 +628,7 @@ def discover_relationships(
 
             # Discover naming pattern relationships
             if "naming_patterns" in relationship_types:
-                naming_relationships = _discover_naming_relationships(
-                    target_table, all_tables
-                )
+                naming_relationships = _discover_naming_relationships(target_table, all_tables)
                 table_relationships["naming_related"] = naming_relationships
                 if naming_relationships:
                     insights.append(
@@ -676,13 +664,9 @@ def discover_relationships(
                 "relationship_summary": {
                     "total_relationships": total_relationships,
                     "tables_analyzed": len(relationships),
-                    "strongest_connections": _identify_strongest_connections(
-                        relationships
-                    ),
+                    "strongest_connections": _identify_strongest_connections(relationships),
                 },
-                "recommendations": _generate_relationship_recommendations(
-                    relationships, insights
-                ),
+                "recommendations": _generate_relationship_recommendations(relationships, insights),
             },
         )
 
@@ -777,16 +761,12 @@ def _analyze_schema_for_discovery(
                 schema_analysis["total_columns"] += len(columns)
 
                 # Find text columns
-                text_columns = [
-                    col for col in columns if "TEXT" in col.get("type", "").upper()
-                ]
+                text_columns = [col for col in columns if "TEXT" in col.get("type", "").upper()]
                 schema_analysis["text_columns_by_table"][table_name] = len(text_columns)
 
                 # Check for well-structured tables
                 has_id = any(col.get("name") == "id" for col in columns)
-                has_timestamp = any(
-                    "timestamp" in col.get("name", "").lower() for col in columns
-                )
+                has_timestamp = any("timestamp" in col.get("name", "").lower() for col in columns)
                 has_text_content = len(text_columns) > 0
 
                 if has_id and has_timestamp and has_text_content:
@@ -798,9 +778,7 @@ def _analyze_schema_for_discovery(
                         f"Table '{table_name}' has very few columns"
                     )
                 if not has_id:
-                    schema_analysis["schema_issues"].append(
-                        f"Table '{table_name}' lacks ID column"
-                    )
+                    schema_analysis["schema_issues"].append(f"Table '{table_name}' lacks ID column")
 
         except Exception:
             continue
@@ -846,9 +824,7 @@ def _assess_content_quality(
                     non_null_fields = sum(
                         1 for v in row.values() if v is not None and str(v).strip()
                     )
-                    total_content_length = sum(
-                        len(str(v)) for v in row.values() if v is not None
-                    )
+                    total_content_length = sum(len(str(v)) for v in row.values() if v is not None)
 
                     # Score based on completeness and content richness
                     if non_null_fields > 2:
@@ -860,9 +836,7 @@ def _assess_content_quality(
 
                     content_scores.append(min(10, row_score))
 
-                table_quality = (
-                    sum(content_scores) / len(content_scores) if content_scores else 0
-                )
+                table_quality = sum(content_scores) / len(content_scores) if content_scores else 0
                 quality_analysis["quality_scores"][table_name] = round(table_quality, 1)
 
                 # Categorize quality
@@ -889,9 +863,7 @@ def _assess_content_quality(
     return quality_analysis
 
 
-def _analyze_search_readiness(
-    db, tables: List[str], focus_area: Optional[str]
-) -> Dict[str, Any]:
+def _analyze_search_readiness(db, tables: List[str], focus_area: Optional[str]) -> Dict[str, Any]:
     """Analyze readiness for effective searching."""
     search_analysis = {
         "semantic_ready_tables": [],
@@ -908,9 +880,7 @@ def _analyze_search_readiness(
             schema_result = db.describe_table(table_name)
             if schema_result.get("success"):
                 columns = schema_result.get("columns", [])
-                text_columns = [
-                    col for col in columns if "TEXT" in col.get("type", "").upper()
-                ]
+                text_columns = [col for col in columns if "TEXT" in col.get("type", "").upper()]
 
                 if text_columns:
                     search_analysis["text_searchable_tables"].append(table_name)
@@ -923,13 +893,9 @@ def _analyze_search_readiness(
                             search_analysis["embedding_coverage"][table_name] = coverage
 
                             if coverage > 80:
-                                search_analysis["semantic_ready_tables"].append(
-                                    table_name
-                                )
+                                search_analysis["semantic_ready_tables"].append(table_name)
                             elif len(text_columns) > 0:
-                                search_analysis["search_optimization_needed"].append(
-                                    table_name
-                                )
+                                search_analysis["search_optimization_needed"].append(table_name)
 
         except Exception:
             continue
@@ -950,15 +916,11 @@ def _generate_discovery_insights(
 
     # Goal-specific insights
     if discovery_goal == "understand_content":
-        insights.append(
-            f"Memory bank contains {total_tables} tables with {total_rows} total rows"
-        )
+        insights.append(f"Memory bank contains {total_tables} tables with {total_rows} total rows")
 
         high_value_tables = overview.get("high_value_tables", [])
         if high_value_tables:
-            insights.append(
-                f"High-value content found in: {', '.join(high_value_tables[:3])}"
-            )
+            insights.append(f"High-value content found in: {', '.join(high_value_tables[:3])}")
             recommendations.append(
                 f"Focus search efforts on high-value tables: {', '.join(high_value_tables)}"
             )
@@ -974,9 +936,7 @@ def _generate_discovery_insights(
     elif discovery_goal == "find_patterns":
         text_rich_tables = overview.get("text_rich_tables", [])
         if text_rich_tables:
-            insights.append(
-                f"Text-rich content found in {len(text_rich_tables)} tables"
-            )
+            insights.append(f"Text-rich content found in {len(text_rich_tables)} tables")
             next_steps.append("Use semantic search to find content patterns")
 
         quality_scores = overview.get("quality_scores", {})
@@ -1010,20 +970,14 @@ def _generate_discovery_insights(
             next_steps.append("Use auto_semantic_search() for conceptual queries")
 
         if optimization_needed:
-            insights.append(
-                f"Search optimization needed for {len(optimization_needed)} tables"
-            )
-            next_steps.append(
-                f"Set up embeddings for: {', '.join(optimization_needed[:2])}"
-            )
+            insights.append(f"Search optimization needed for {len(optimization_needed)} tables")
+            next_steps.append(f"Set up embeddings for: {', '.join(optimization_needed[:2])}")
 
     # Universal recommendations
     if overview.get("semantic_search_available"):
         recommendations.append("Use auto_smart_search() for best search results")
     else:
-        recommendations.append(
-            "Install sentence-transformers for semantic search capabilities"
-        )
+        recommendations.append("Install sentence-transformers for semantic search capabilities")
 
     if not next_steps:
         next_steps.append("Use explore_tables() for detailed content examination")
@@ -1077,9 +1031,7 @@ def _store_discovery_pattern(db, discovery_session: Dict[str, Any]) -> None:
     try:
         # Check if discovery_patterns table exists
         tables_result = db.list_tables()
-        if tables_result.get("success") and "discovery_patterns" in tables_result.get(
-            "tables", []
-        ):
+        if tables_result.get("success") and "discovery_patterns" in tables_result.get("tables", []):
             # Store the discovery session
             db.insert_row(
                 "discovery_patterns",
@@ -1088,9 +1040,7 @@ def _store_discovery_pattern(db, discovery_session: Dict[str, Any]) -> None:
                     "goal": discovery_session.get("goal"),
                     "focus_area": discovery_session.get("focus_area"),
                     "depth": discovery_session.get("depth"),
-                    "steps_completed": str(
-                        discovery_session.get("steps_completed", [])
-                    ),
+                    "steps_completed": str(discovery_session.get("steps_completed", [])),
                     "success": True,
                     "timestamp": discovery_session.get("timestamp"),
                 },
@@ -1156,20 +1106,13 @@ def _discover_foreign_keys(db, target_table: str, all_tables: List[str]) -> List
                         col_name = col.get("name", "")
                         # Look for naming patterns that suggest foreign keys
                         if col_name.endswith("_id") or col_name.endswith("Id"):
-                            potential_ref = col_name.replace("_id", "").replace(
-                                "Id", ""
-                            )
-                            if (
-                                potential_ref == target_table
-                                or f"{potential_ref}s" == target_table
-                            ):
+                            potential_ref = col_name.replace("_id", "").replace("Id", "")
+                            if potential_ref == target_table or f"{potential_ref}s" == target_table:
                                 relationships.append(f"{other_table}.{col_name}")
 
                         # Look for exact column name matches (potential shared keys)
                         if col_name in target_col_names and col_name != "id":
-                            relationships.append(
-                                f"{other_table}.{col_name} (shared key)"
-                            )
+                            relationships.append(f"{other_table}.{col_name} (shared key)")
 
             except Exception:
                 continue
@@ -1197,9 +1140,7 @@ def _discover_semantic_relationships(
 
         # Create a sample query from target table content
         sample_row = target_rows["rows"][0]
-        sample_text = " ".join(str(v) for v in sample_row.values() if v is not None)[
-            :200
-        ]
+        sample_text = " ".join(str(v) for v in sample_row.values() if v is not None)[:200]
 
         if len(sample_text.strip()) < 10:
             return relationships
@@ -1223,9 +1164,9 @@ def _discover_semantic_relationships(
 
                 if search_result.get("success") and search_result.get("results"):
                     results = search_result["results"]
-                    avg_similarity = sum(
-                        r.get("similarity_score", 0) for r in results
-                    ) / len(results)
+                    avg_similarity = sum(r.get("similarity_score", 0) for r in results) / len(
+                        results
+                    )
 
                     if avg_similarity >= threshold:
                         relationships.append(
@@ -1245,9 +1186,7 @@ def _discover_semantic_relationships(
     return relationships
 
 
-def _discover_temporal_relationships(
-    db, target_table: str, all_tables: List[str]
-) -> List[str]:
+def _discover_temporal_relationships(db, target_table: str, all_tables: List[str]) -> List[str]:
     """Discover temporal pattern relationships."""
     relationships = []
 
@@ -1296,9 +1235,7 @@ def _discover_temporal_relationships(
     return relationships
 
 
-def _discover_naming_relationships(
-    target_table: str, all_tables: List[str]
-) -> List[str]:
+def _discover_naming_relationships(target_table: str, all_tables: List[str]) -> List[str]:
     """Discover relationships based on naming conventions."""
     relationships = []
 

mcp_sqlite_memory_bank/tools/search.py

@@ -7,12 +7,11 @@ semantic search, embedding management, and intelligent search capabilities.
 
 import logging
 import traceback
-from typing import Any, Dict, List, Optional, cast
+from typing import List, Optional, cast
 
 from ..database import get_database
-from ..types import MemoryBankError, DatabaseError, ToolResponse
+from ..types import ToolResponse
 from ..utils import catch_errors
-from ..semantic import is_semantic_search_available
 
 
 @catch_errors
@@ -24,9 +23,7 @@ def search_content(
     """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)
-    )
+    return cast(ToolResponse, get_database(server.DB_PATH).search_content(query, tables, limit))
 
 
 @catch_errors
@@ -228,10 +225,7 @@ def auto_semantic_search(
                 columns = schema_result.get("columns", [])
                 if isinstance(columns, list):
                     for col in columns:
-                        if (
-                            isinstance(col, dict)
-                            and "TEXT" in col.get("type", "").upper()
-                        ):
+                        if isinstance(col, dict) and "TEXT" in col.get("type", "").upper():
                             text_columns.append(col["name"])
 
                 # Auto-embed text columns
@@ -365,10 +359,7 @@ def auto_smart_search(
                 columns = schema_result.get("columns", [])
                 if isinstance(columns, list):
                     for col in columns:
-                        if (
-                            isinstance(col, dict)
-                            and "TEXT" in col.get("type", "").upper()
-                        ):
+                        if isinstance(col, dict) and "TEXT" in col.get("type", "").upper():
                             text_columns.append(col["name"])
 
                 # Auto-embed text columns
@@ -397,9 +388,7 @@ def auto_smart_search(
             )
         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}"
-            )
+            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

mcp_sqlite_memory_bank/utils.py

@@ -110,9 +110,7 @@ def get_table_columns(conn: sqlite3.Connection, table_name: str) -> List[str]:
     cur.execute(f"PRAGMA table_info({table_name})")
     columns = [row[1] for row in cur.fetchall()]
     if not columns:
-        raise SchemaError(
-            f"Table does not exist: {table_name}", {"table_name": table_name}
-        )
+        raise SchemaError(f"Table does not exist: {table_name}", {"table_name": table_name})
     return columns
 
 
@@ -164,13 +162,9 @@ def validate_table_exists(conn: sqlite3.Connection, table_name: str) -> None:
         table_name: Name of table to check
     """
     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():
-        raise SchemaError(
-            f"Table does not exist: {table_name}", {"table_name": table_name}
-        )
+        raise SchemaError(f"Table does not exist: {table_name}", {"table_name": table_name})
 
 
 def build_where_clause(
@@ -229,7 +223,6 @@ def suggest_recovery(error: Exception, function_name: str) -> Dict[str, Any]:
     }
 
     error_str = str(error).lower()
-    error_type = type(error).__name__
 
     # Dependency-related errors
     if "sentence-transformers" in error_str or "transformers" in error_str:
@@ -382,9 +375,7 @@ def enhanced_catch_errors(
 
                 # Determine error category
                 if isinstance(e, MemoryBankError):
-                    category = (
-                        e.category.name if hasattr(e, "category") else "MEMORY_BANK"
-                    )
+                    category = e.category.name if hasattr(e, "category") else "MEMORY_BANK"
                     return cast(
                         ToolResponse,
                         {

{mcp_sqlite_memory_bank-1.6.0.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.6.0
+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

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.6.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-mcp_sqlite_memory_bank/__init__.py,sha256=watSgbtYk6AHB57GzJ09w_KXSPMqnyKFRk6cnQ5hCF0,2795
-mcp_sqlite_memory_bank/__main__.py,sha256=AZ6JPKw1C2hM2MdB6opAysXFFGaO5aXcLbkMVNlxzxU,2110
-mcp_sqlite_memory_bank/database.py,sha256=NadWM9QB_5TOVmtKBHwZSJjIdg4KD0TiTBn9oU4tjyw,50489
-mcp_sqlite_memory_bank/prompts.py,sha256=x9EfzAaWPXlpblM2cDyPV5xuG0Q3pjXmT64g1TVQ5RM,11901
-mcp_sqlite_memory_bank/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_sqlite_memory_bank/resources.py,sha256=GF_Lqr-Of6e0R2ZauCASdlfafQxZUzCHKrIU6aLkmyI,23720
-mcp_sqlite_memory_bank/semantic.py,sha256=ZxYmZetn_bvqE-bW6Sy_MMpsKhXnO4KgplgVO5CvHNQ,16021
-mcp_sqlite_memory_bank/server.py,sha256=V3dLdsKSJcQCWWSN_VFchHeDmxF3xfW2aA0VI8k3qps,49694
-mcp_sqlite_memory_bank/types.py,sha256=kK8HUz3szwiV9cUJkO56RpnosXEssQT1t0w_166ik5k,6756
-mcp_sqlite_memory_bank/utils.py,sha256=08sdnEBLFhaGg3zrqOFPkLdv2ZnTZ8ggWe-ILysNlDk,15217
-mcp_sqlite_memory_bank/tools/__init__.py,sha256=00TDY78qXLdeaXxcK53xFKlEiY9flHQCuIGnEh5rghg,1786
-mcp_sqlite_memory_bank/tools/analytics.py,sha256=B7Rc1t6Imf7cC4NRgjGETYdSrfMt5wqE7plr-UpaC-k,20530
-mcp_sqlite_memory_bank/tools/basic.py,sha256=TSoleUkDwizaE2A4r3G2g92rNTOImXV5inhy8sBfnFQ,18414
-mcp_sqlite_memory_bank/tools/discovery.py,sha256=NIYY-UX5OfzE0pLGToHF9j9KvBPzWOPM3DR3J-afWzo,57290
-mcp_sqlite_memory_bank/tools/search.py,sha256=5Nek8xWPtlcBlVcHM4tDeZ1wiUxX_ispwaDOB5k6sAo,17311
-mcp_sqlite_memory_bank-1.6.0.dist-info/licenses/LICENSE,sha256=KPr7eFgCJqQIjeSAcwRafbjcgm-10zkrJ7MFoTOGJQg,1092
-mcp_sqlite_memory_bank-1.6.0.dist-info/METADATA,sha256=wbjNDb6LCETv8OqYiowtKObEzskMl1k6WwG87vPO8Q4,35536
-mcp_sqlite_memory_bank-1.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_sqlite_memory_bank-1.6.0.dist-info/entry_points.txt,sha256=S9yGWiCe8f_rgcGCgbwEAX2FfJ9jXWxcc4K4Jenbcn8,150
-mcp_sqlite_memory_bank-1.6.0.dist-info/top_level.txt,sha256=xQ8MTGECpWMR-9DV4H8mMqaSoZqE-C8EvpOg9E2U1wM,23
-mcp_sqlite_memory_bank-1.6.0.dist-info/RECORD,,