mcp-sqlite-memory-bank 1.3.0__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)