mcp-sqlite-memory-bank 1.3.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

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 ---
 
@@ -458,9 +466,9 @@ def explore_tables(pattern: Optional[str] = None, include_row_counts: bool = Tru
 
 @mcp.tool
 @catch_errors
-def add_embeddings(table_name: str, text_columns: List[str], 
-                  embedding_column: str = "embedding",
-                  model_name: str = "all-MiniLM-L6-v2") -> ToolResponse:
+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.
 
@@ -488,19 +496,23 @@ def add_embeddings(table_name: str, text_columns: List[str],
         - Uses efficient batch processing for large datasets
         - Supports various sentence-transformer models for different use cases
     """
-    return cast(ToolResponse, get_database(DB_PATH).generate_embeddings(
-        table_name, text_columns, embedding_column, model_name
-    ))
+    return cast(
+        ToolResponse, get_database(DB_PATH).generate_embeddings(table_name, text_columns, embedding_column, model_name)
+    )
 
 
-@mcp.tool  
+@mcp.tool
 @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:
+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.
-    
+
     This enables intelligent knowledge discovery - find related concepts even when
     they use different terminology or phrasing.
 
@@ -532,18 +544,26 @@ def semantic_search(query: str, tables: Optional[List[str]] = None,
         - Supports fuzzy matching and concept discovery
         - Much more powerful than keyword-based search for knowledge discovery
     """
-    return cast(ToolResponse, get_database(DB_PATH).semantic_search(
-        query, tables, "embedding", None, similarity_threshold, limit, model_name
-    ))
+    return cast(
+        ToolResponse,
+        get_database(DB_PATH).semantic_search(
+            query, tables, "embedding", None, similarity_threshold, limit, model_name
+        ),
+    )
 
 
 @mcp.tool
-@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:
+@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.
-    
+
     Discover connections and related information that might not be obvious
     from direct references or tags.
 
@@ -559,7 +579,7 @@ def find_related(table_name: str, row_id: int, similarity_threshold: float = 0.5
                      On error: {"success": False, "error": str, "category": str, "details": dict}
 
     Examples:
-        >>> find_related("technical_decisions", 5)  
+        >>> find_related("technical_decisions", 5)
         {"success": True, "results": [
             {"id": 12, "similarity_score": 0.84, "decision_name": "Related Architecture Choice", ...},
             {"id": 3, "similarity_score": 0.71, "decision_name": "Similar Technology Decision", ...}
@@ -571,19 +591,27 @@ def find_related(table_name: str, row_id: int, similarity_threshold: float = 0.5
         - Can reveal patterns and themes across your knowledge base
         - Enables serendipitous discovery of relevant information
     """
-    return cast(ToolResponse, get_database(DB_PATH).find_related_content(
-        table_name, row_id, "embedding", similarity_threshold, limit, model_name
-    ))
+    return cast(
+        ToolResponse,
+        get_database(DB_PATH).find_related_content(
+            table_name, row_id, "embedding", similarity_threshold, limit, model_name
+        ),
+    )
 
 
 @mcp.tool
 @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:
+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.
-    
+
     Provides the best of both worlds - semantic similarity for concept discovery
     plus exact text matching for precise searches.
 
@@ -609,13 +637,16 @@ def smart_search(query: str, tables: Optional[List[str]] = None,
     FastMCP Tool Info:
         - Automatically balances semantic and keyword search
         - Provides separate scores for transparency
-        - Falls back gracefully if semantic search unavailable  
+        - Falls back gracefully if semantic search unavailable
         - Optimal for both exploratory and precise searches
         - Recommended for general-purpose knowledge discovery
     """
-    return cast(ToolResponse, get_database(DB_PATH).hybrid_search(
-        query, tables, None, "embedding", semantic_weight, text_weight, limit, model_name
-    ))
+    return cast(
+        ToolResponse,
+        get_database(DB_PATH).hybrid_search(
+            query, tables, None, "embedding", semantic_weight, text_weight, limit, model_name
+        ),
+    )
 
 
 @mcp.tool
@@ -623,7 +654,7 @@ def smart_search(query: str, tables: Optional[List[str]] = None,
 def embedding_stats(table_name: str, embedding_column: str = "embedding") -> ToolResponse:
     """
     Get statistics about semantic search readiness for a table.
-    
+
     Check which content has embeddings and can be searched semantically.
 
     Args:
@@ -636,7 +667,7 @@ def embedding_stats(table_name: str, embedding_column: str = "embedding") -> Too
 
     Examples:
         >>> embedding_stats("technical_decisions")
-        {"success": True, "total_rows": 25, "embedded_rows": 25, "coverage_percent": 100.0, 
+        {"success": True, "total_rows": 25, "embedded_rows": 25, "coverage_percent": 100.0,
          "embedding_dimensions": 384}
 
     FastMCP Tool Info:
@@ -648,6 +679,122 @@ def embedding_stats(table_name: str, embedding_column: str = "embedding") -> Too
     return cast(ToolResponse, get_database(DB_PATH).get_embedding_stats(table_name, embedding_column))
 
 
+# --- 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}]}
+    """
+    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]),
+    })
+
+
+# ...existing code...
+
+
 # Export the FastMCP app for use in other modules and server runners
 app = mcp
 
@@ -689,7 +836,10 @@ def _create_row_impl(table_name: str, data: Dict[str, Any]) -> Dict[str, Any]:
             try:
                 current_db.create_table(
                     "nodes",
-                    [{"name": "id", "type": "INTEGER PRIMARY KEY AUTOINCREMENT"}, {"name": "label", "type": "TEXT NOT NULL"}],
+                    [
+                        {"name": "id", "type": "INTEGER PRIMARY KEY AUTOINCREMENT"},
+                        {"name": "label", "type": "TEXT NOT NULL"},
+                    ],
                 )
             except Exception:
                 pass  # Table might already exist

mcp_sqlite_memory_bank/types.py

@@ -182,6 +182,7 @@ class ExploreTablesResponse(SuccessResponse):
 # Semantic Search Response Types
 class SemanticSearchResponse(TypedDict):
     """Response type for semantic search operations."""
+
     success: bool
     results: List[Dict[str, Any]]
     query: str
@@ -193,6 +194,7 @@ class SemanticSearchResponse(TypedDict):
 
 class RelatedContentResponse(TypedDict, total=False):
     """Response type for find related content operations."""
+
     success: bool
     results: List[Dict[str, Any]]
     target_row: Dict[str, Any]
@@ -204,6 +206,7 @@ class RelatedContentResponse(TypedDict, total=False):
 
 class HybridSearchResponse(TypedDict):
     """Response type for hybrid search operations."""
+
     success: bool
     results: List[Dict[str, Any]]
     query: str
@@ -216,6 +219,7 @@ class HybridSearchResponse(TypedDict):
 
 class EmbeddingStatsResponse(TypedDict):
     """Response type for embedding statistics."""
+
     success: bool
     table_name: str
     total_rows: int
@@ -227,6 +231,7 @@ class EmbeddingStatsResponse(TypedDict):
 
 class GenerateEmbeddingsResponse(TypedDict):
     """Response type for embedding generation operations."""
+
     success: bool
     message: str
     processed: int
@@ -236,6 +241,7 @@ class GenerateEmbeddingsResponse(TypedDict):
 
 class EmbeddingColumnResponse(TypedDict):
     """Response type for adding embedding columns."""
+
     success: bool
     message: str
 

mcp_sqlite_memory_bank/utils.py

@@ -31,7 +31,9 @@ def catch_errors(f: T) -> T:
             return cast(ToolResponse, e.to_dict())
         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())
+            return cast(
+                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())
@@ -50,7 +52,8 @@ def validate_identifier(name: str, context: str = "identifier") -> None:
     """
     if not bool(re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", name)):
         raise ValidationError(
-            f"Invalid {context}: {name}. Must start with letter/underscore and " f"contain only letters, numbers, underscores.",
+            f"Invalid {context}: {name}. Must start with letter/underscore and "
+            f"contain only letters, numbers, underscores.",
             {"invalid_name": name},
         )
 

{mcp_sqlite_memory_bank-1.3.0.dist-info → mcp_sqlite_memory_bank-1.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp_sqlite_memory_bank
-Version: 1.3.0
+Version: 1.4.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
@@ -16,6 +16,10 @@ Requires-Dist: fastapi>=0.100.0
 Requires-Dist: uvicorn>=0.22.0
 Requires-Dist: pydantic>=1.10.0
 Requires-Dist: fastmcp
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: sentence-transformers>=2.2.0
+Requires-Dist: torch>=1.9.0
+Requires-Dist: numpy>=1.21.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Dynamic: license-file
@@ -36,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
 
@@ -104,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 |
 |------|-------------|---------------------|---------------------|
@@ -126,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 |
 |------|-------------|---------------------|---------------------|
@@ -136,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.
 
 ---
@@ -464,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.1.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=kBHiibDV2ucm9alaDrNB-txm7v-hGt-uTNHIFKuFlKI,41873
+mcp_sqlite_memory_bank/prompts.py,sha256=AYTpyxRh_YacQQ4SfFJIXGLLyxWaAVmEnkZ9-fgZv1c,11320
+mcp_sqlite_memory_bank/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_sqlite_memory_bank/resources.py,sha256=g1IId2yCDQuv0zC5oEzBGhEZrDgi6z3wKpJZujXsr0Y,6869
+mcp_sqlite_memory_bank/semantic.py,sha256=XVfM1C95TdZDtXOrwrGxR5JZnmeeO4O45gxniPWa6go,14791
+mcp_sqlite_memory_bank/server.py,sha256=2isYtWyGFIVE1kOE_HWJR0R610YHHWCduKb6srC5ajM,40222
+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.1.dist-info/licenses/LICENSE,sha256=KPr7eFgCJqQIjeSAcwRafbjcgm-10zkrJ7MFoTOGJQg,1092
+mcp_sqlite_memory_bank-1.4.1.dist-info/METADATA,sha256=DJa6MX4cN5wxlX-sr0W8MaGuZgeASXkl-XsX7Z9kw7w,33094
+mcp_sqlite_memory_bank-1.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_sqlite_memory_bank-1.4.1.dist-info/entry_points.txt,sha256=S9yGWiCe8f_rgcGCgbwEAX2FfJ9jXWxcc4K4Jenbcn8,150
+mcp_sqlite_memory_bank-1.4.1.dist-info/top_level.txt,sha256=xQ8MTGECpWMR-9DV4H8mMqaSoZqE-C8EvpOg9E2U1wM,23
+mcp_sqlite_memory_bank-1.4.1.dist-info/RECORD,,

mcp_sqlite_memory_bank-1.3.0.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=OaFHUQdsd9kCdaS1F8f5Z5jdaGmedZUbG-ZvProkvvI,41565
-mcp_sqlite_memory_bank/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_sqlite_memory_bank/semantic.py,sha256=-QA1XDMlptIwsEDllBzGZS6si26QIdIaIgAiszVkckY,15609
-mcp_sqlite_memory_bank/server.py,sha256=U2iX7JbYBiIwtIWMHET2gZ_M97HrMmskfrvAS5fL8Wg,33775
-mcp_sqlite_memory_bank/types.py,sha256=Uz4CsnIR_MU8LAl2BbAqYWVJTogiYi_8-cr0Gg4foYs,6523
-mcp_sqlite_memory_bank/utils.py,sha256=oF2VNXvxH_yzuipfYZsG6AMB7K0lWFr9Lupz6Cc7sM0,6140
-mcp_sqlite_memory_bank-1.3.0.dist-info/licenses/LICENSE,sha256=KPr7eFgCJqQIjeSAcwRafbjcgm-10zkrJ7MFoTOGJQg,1092
-mcp_sqlite_memory_bank-1.3.0.dist-info/METADATA,sha256=z9MVNNrsnI3So7w72lxoUknyYkM0dFp_jFd85QhdMQg,25864
-mcp_sqlite_memory_bank-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_sqlite_memory_bank-1.3.0.dist-info/entry_points.txt,sha256=S9yGWiCe8f_rgcGCgbwEAX2FfJ9jXWxcc4K4Jenbcn8,150
-mcp_sqlite_memory_bank-1.3.0.dist-info/top_level.txt,sha256=xQ8MTGECpWMR-9DV4H8mMqaSoZqE-C8EvpOg9E2U1wM,23
-mcp_sqlite_memory_bank-1.3.0.dist-info/RECORD,,