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

mcp_sqlite_memory_bank/prompts.py

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

mcp_sqlite_memory_bank/resources.py

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

mcp_sqlite_memory_bank/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 ---
 
@@ -671,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
 

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

{mcp_sqlite_memory_bank-1.3.1.dist-info → mcp_sqlite_memory_bank-1.4.1.dist-info}/RECORD

@@ -1,13 +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=lt_1LSXDDJoSATNd4T07GmfPqlYcdQlmwDGR_TySboM,33896
+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.3.1.dist-info/licenses/LICENSE,sha256=KPr7eFgCJqQIjeSAcwRafbjcgm-10zkrJ7MFoTOGJQg,1092
-mcp_sqlite_memory_bank-1.3.1.dist-info/METADATA,sha256=xgs7hG0Uu1Sr6Qpj_HR6wHz48P4wxTQmD_CbSknsLus,26002
-mcp_sqlite_memory_bank-1.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_sqlite_memory_bank-1.3.1.dist-info/entry_points.txt,sha256=S9yGWiCe8f_rgcGCgbwEAX2FfJ9jXWxcc4K4Jenbcn8,150
-mcp_sqlite_memory_bank-1.3.1.dist-info/top_level.txt,sha256=xQ8MTGECpWMR-9DV4H8mMqaSoZqE-C8EvpOg9E2U1wM,23
-mcp_sqlite_memory_bank-1.3.1.dist-info/RECORD,,
+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,,