memorygraphMCP 0.11.7__py3-none-any.whl

memorygraph/tools/__init__.py

@@ -0,0 +1,59 @@
+"""
+Tool handlers for the MCP server.
+
+This package contains modular tool handlers organized by functionality:
+- memory_tools: CRUD operations for memories
+- relationship_tools: Create and query relationships
+- search_tools: Search, recall, and contextual search for memories
+- activity_tools: Activity summaries and statistics
+- temporal_tools: Bi-temporal queries and time-travel operations
+"""
+
+from .memory_tools import (
+    handle_store_memory,
+    handle_get_memory,
+    handle_update_memory,
+    handle_delete_memory,
+)
+from .relationship_tools import (
+    handle_create_relationship,
+    handle_get_related_memories,
+)
+from .search_tools import (
+    handle_search_memories,
+    handle_recall_memories,
+    handle_contextual_search,
+)
+from .activity_tools import (
+    handle_get_memory_statistics,
+    handle_get_recent_activity,
+    handle_search_relationships_by_context,
+)
+from .temporal_tools import (
+    handle_query_as_of,
+    handle_get_relationship_history,
+    handle_what_changed,
+)
+
+__all__ = [
+    # Memory CRUD operations
+    "handle_store_memory",
+    "handle_get_memory",
+    "handle_update_memory",
+    "handle_delete_memory",
+    # Relationship operations
+    "handle_create_relationship",
+    "handle_get_related_memories",
+    # Search operations
+    "handle_search_memories",
+    "handle_recall_memories",
+    "handle_contextual_search",
+    # Activity and statistics
+    "handle_get_memory_statistics",
+    "handle_get_recent_activity",
+    "handle_search_relationships_by_context",
+    # Temporal operations
+    "handle_query_as_of",
+    "handle_get_relationship_history",
+    "handle_what_changed",
+]

memorygraph/tools/activity_tools.py

@@ -0,0 +1,262 @@
+"""
+Activity and statistics tool handlers for the MCP server.
+
+This module contains handlers for activity and statistics operations:
+- get_recent_activity: Get summary of recent memory activity
+- get_memory_statistics: Get statistics about the memory database
+- search_relationships_by_context: Search relationships by structured context fields
+"""
+
+import logging
+from typing import Any, Dict
+
+from mcp.types import CallToolResult, TextContent
+
+from ..database import MemoryDatabase
+from ..sqlite_database import SQLiteMemoryDatabase
+
+logger = logging.getLogger(__name__)
+
+
+async def handle_get_memory_statistics(
+    memory_db: MemoryDatabase,
+    arguments: Dict[str, Any]
+) -> CallToolResult:
+    """Handle get_memory_statistics tool call.
+
+    Args:
+        memory_db: Database instance for memory operations
+        arguments: Tool arguments from MCP call (no parameters required)
+
+    Returns:
+        CallToolResult with formatted statistics or error message
+    """
+    try:
+        stats = await memory_db.get_memory_statistics()
+
+        # Format statistics
+        stats_text = "**Memory Database Statistics**\n\n"
+
+        if stats.get("total_memories"):
+            stats_text += f"Total Memories: {stats['total_memories']['count']}\n"
+
+        if stats.get("memories_by_type"):
+            stats_text += "\n**Memories by Type:**\n"
+            for mem_type, count in stats["memories_by_type"].items():
+                stats_text += f"- {mem_type}: {count}\n"
+
+        if stats.get("total_relationships"):
+            stats_text += f"\nTotal Relationships: {stats['total_relationships']['count']}\n"
+
+        if stats.get("avg_importance"):
+            stats_text += f"Average Importance: {stats['avg_importance']['avg_importance']:.2f}\n"
+
+        if stats.get("avg_confidence"):
+            stats_text += f"Average Confidence: {stats['avg_confidence']['avg_confidence']:.2f}\n"
+
+        return CallToolResult(
+            content=[TextContent(type="text", text=stats_text)]
+        )
+    except Exception as e:
+        logger.error(f"Failed to get memory statistics: {e}")
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Failed to get memory statistics: {e}"
+            )],
+            isError=True
+        )
+
+
+async def handle_get_recent_activity(
+    memory_db: MemoryDatabase,
+    arguments: Dict[str, Any]
+) -> CallToolResult:
+    """Handle get_recent_activity tool call.
+
+    Args:
+        memory_db: Database instance for memory operations
+        arguments: Tool arguments from MCP call containing:
+            - days: Number of days to look back (default: 7)
+            - project: Optional project path to filter by
+
+    Returns:
+        CallToolResult with formatted activity summary or error message
+    """
+    try:
+        # Check if database supports get_recent_activity
+        if not isinstance(memory_db, SQLiteMemoryDatabase):
+            return CallToolResult(
+                content=[TextContent(
+                    type="text",
+                    text="Recent activity summary is only available with SQLite backend"
+                )],
+                isError=True
+            )
+
+        days = arguments.get("days", 7)
+        project = arguments.get("project")
+
+        # Auto-detect project if not specified
+        if not project:
+            from ..utils.project_detection import detect_project_context
+            project_info = detect_project_context()
+            if project_info:
+                project = project_info.get("project_path")
+
+        activity = await memory_db.get_recent_activity(days=days, project=project)
+
+        # Format results
+        result_text = f"**Recent Activity Summary (Last {days} days)**\n\n"
+
+        if project:
+            result_text += f"**Project**: {project}\n\n"
+
+        # Total count
+        result_text += f"**Total Memories**: {activity['total_count']}\n\n"
+
+        # Memories by type
+        if activity['memories_by_type']:
+            result_text += "**Breakdown by Type**:\n"
+            for mem_type, count in sorted(activity['memories_by_type'].items(), key=lambda x: x[1], reverse=True):
+                result_text += f"- {mem_type.replace('_', ' ').title()}: {count}\n"
+            result_text += "\n"
+
+        # Unresolved problems
+        if activity['unresolved_problems']:
+            result_text += f"**⚠️ Unresolved Problems ({len(activity['unresolved_problems'])})**:\n"
+            for problem in activity['unresolved_problems']:
+                result_text += f"- **{problem.title}** (importance: {problem.importance:.1f})\n"
+                if problem.summary:
+                    result_text += f"  {problem.summary}\n"
+            result_text += "\n"
+
+        # Recent memories
+        if activity['recent_memories']:
+            result_text += f"**Recent Memories** (showing {min(10, len(activity['recent_memories']))}):\n"
+            for i, memory in enumerate(activity['recent_memories'][:10], 1):
+                result_text += f"{i}. **{memory.title}** ({memory.type.value})\n"
+                if memory.summary:
+                    result_text += f"   {memory.summary}\n"
+            result_text += "\n"
+
+        # Next steps suggestion
+        result_text += "**💡 Next Steps**:\n"
+        if activity['unresolved_problems']:
+            result_text += "- Review unresolved problems and consider solutions\n"
+            result_text += f"- Use `get_memory(memory_id=\"...\")` for details\n"
+        else:
+            result_text += "- All problems have been addressed!\n"
+
+        return CallToolResult(
+            content=[TextContent(type="text", text=result_text)]
+        )
+
+    except Exception as e:
+        logger.error(f"Error in get_recent_activity: {e}")
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Failed to get recent activity: {e}"
+            )],
+            isError=True
+        )
+
+
+async def handle_search_relationships_by_context(
+    memory_db: MemoryDatabase,
+    arguments: Dict[str, Any]
+) -> CallToolResult:
+    """Handle search_relationships_by_context tool call.
+
+    Args:
+        memory_db: Database instance for memory operations
+        arguments: Tool arguments from MCP call containing:
+            - scope: Filter by scope (partial/full/conditional, optional)
+            - conditions: Filter by conditions (optional)
+            - has_evidence: Filter by presence/absence of evidence (optional)
+            - evidence: Filter by specific evidence types (optional)
+            - components: Filter by components mentioned (optional)
+            - temporal: Filter by temporal information (optional)
+            - limit: Maximum results (default: 20)
+
+    Returns:
+        CallToolResult with formatted relationship results or error message
+    """
+    try:
+        # Use SQLiteMemoryDatabase's search_relationships_by_context method
+        if not isinstance(memory_db, SQLiteMemoryDatabase):
+            return CallToolResult(
+                content=[TextContent(
+                    type="text",
+                    text="Context-based relationship search is only available with SQLite backend"
+                )],
+                isError=True
+            )
+
+        relationships = await memory_db.search_relationships_by_context(
+            scope=arguments.get("scope"),
+            conditions=arguments.get("conditions"),
+            has_evidence=arguments.get("has_evidence"),
+            evidence=arguments.get("evidence"),
+            components=arguments.get("components"),
+            temporal=arguments.get("temporal"),
+            limit=arguments.get("limit", 20)
+        )
+
+        if not relationships:
+            return CallToolResult(
+                content=[TextContent(
+                    type="text",
+                    text="No relationships found matching the specified context criteria"
+                )]
+            )
+
+        # Format results
+        result_text = f"**Found {len(relationships)} relationships matching context criteria**\n\n"
+
+        # Show applied filters
+        filters_applied = []
+        if arguments.get("scope"):
+            filters_applied.append(f"Scope: {arguments['scope']}")
+        if arguments.get("conditions"):
+            filters_applied.append(f"Conditions: {', '.join(arguments['conditions'])}")
+        if arguments.get("has_evidence") is not None:
+            filters_applied.append(f"Has Evidence: {arguments['has_evidence']}")
+        if arguments.get("evidence"):
+            filters_applied.append(f"Evidence: {', '.join(arguments['evidence'])}")
+        if arguments.get("components"):
+            filters_applied.append(f"Components: {', '.join(arguments['components'])}")
+        if arguments.get("temporal"):
+            filters_applied.append(f"Temporal: {arguments['temporal']}")
+
+        if filters_applied:
+            result_text += "**Filters Applied:**\n"
+            for f in filters_applied:
+                result_text += f"- {f}\n"
+            result_text += "\n"
+
+        # List relationships
+        for i, rel in enumerate(relationships, 1):
+            result_text += f"{i}. **{rel.type.value}**\n"
+            result_text += f"   - ID: {rel.id}\n"
+            result_text += f"   - From: {rel.from_memory_id}\n"
+            result_text += f"   - To: {rel.to_memory_id}\n"
+            result_text += f"   - Strength: {rel.properties.strength:.2f}\n"
+            if rel.properties.context:
+                result_text += f"   - Context: {rel.properties.context}\n"
+            result_text += "\n"
+
+        return CallToolResult(
+            content=[TextContent(type="text", text=result_text)]
+        )
+
+    except Exception as e:
+        logger.error(f"Error in search_relationships_by_context: {e}")
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Failed to search relationships by context: {e}"
+            )],
+            isError=True
+        )

memorygraph/tools/memory_tools.py

@@ -0,0 +1,315 @@
+"""
+Memory CRUD tool handlers for the MCP server.
+
+This module contains handlers for basic memory operations:
+- store_memory: Create new memories
+- get_memory: Retrieve a memory by ID
+- update_memory: Modify an existing memory
+- delete_memory: Remove a memory and its relationships
+"""
+
+import logging
+from typing import Any, Dict
+
+from mcp.types import CallToolResult, TextContent
+from pydantic import ValidationError
+
+from ..database import MemoryDatabase
+from ..models import Memory, MemoryType, MemoryContext
+
+logger = logging.getLogger(__name__)
+
+
+async def handle_store_memory(
+    memory_db: MemoryDatabase,
+    arguments: Dict[str, Any]
+) -> CallToolResult:
+    """Handle store_memory tool call.
+
+    Args:
+        memory_db: Database instance for memory operations
+        arguments: Tool arguments from MCP call containing:
+            - type: Memory type (solution, problem, error, etc.)
+            - title: Short descriptive title
+            - content: Detailed content
+            - summary: Optional brief summary
+            - tags: Optional list of tags
+            - importance: Optional importance score (0.0-1.0)
+            - context: Optional context information
+
+    Returns:
+        CallToolResult with memory ID on success or error message on failure
+    """
+    try:
+        # Extract context if provided
+        context = None
+        if "context" in arguments:
+            context = MemoryContext(**arguments["context"])
+
+        # Create memory object
+        memory = Memory(
+            type=MemoryType(arguments["type"]),
+            title=arguments["title"],
+            content=arguments["content"],
+            summary=arguments.get("summary"),
+            tags=arguments.get("tags", []),
+            importance=arguments.get("importance", 0.5),
+            context=context
+        )
+
+        # Store in database
+        memory_id = await memory_db.store_memory(memory)
+
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Memory stored successfully with ID: {memory_id}"
+            )]
+        )
+
+    except (ValidationError, KeyError, ValueError) as e:
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Validation error: {e}"
+            )],
+            isError=True
+        )
+    except Exception as e:
+        logger.error(f"Failed to store memory: {e}")
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Failed to store memory: {e}"
+            )],
+            isError=True
+        )
+
+
+async def handle_get_memory(
+    memory_db: MemoryDatabase,
+    arguments: Dict[str, Any]
+) -> CallToolResult:
+    """Handle get_memory tool call.
+
+    Args:
+        memory_db: Database instance for memory operations
+        arguments: Tool arguments from MCP call containing:
+            - memory_id: ID of memory to retrieve
+            - include_relationships: Whether to include related memories (default: True)
+
+    Returns:
+        CallToolResult with formatted memory details or error message
+    """
+    try:
+        memory_id = arguments["memory_id"]
+        include_relationships = arguments.get("include_relationships", True)
+
+        memory = await memory_db.get_memory(memory_id, include_relationships)
+
+        if not memory:
+            return CallToolResult(
+                content=[TextContent(
+                    type="text",
+                    text=f"Memory not found: {memory_id}"
+                )],
+                isError=True
+            )
+
+        # Format memory for display
+        memory_text = f"""**Memory: {memory.title}**
+Type: {memory.type.value}
+Created: {memory.created_at}
+Importance: {memory.importance}
+Tags: {', '.join(memory.tags) if memory.tags else 'None'}
+
+**Content:**
+{memory.content}"""
+
+        if memory.summary:
+            memory_text = f"**Summary:** {memory.summary}\n\n" + memory_text
+
+        # Add context information if available
+        if memory.context:
+            context_parts = []
+
+            if memory.context.project_path:
+                context_parts.append(f"Project: {memory.context.project_path}")
+
+            if memory.context.files_involved:
+                files_str = ', '.join(memory.context.files_involved[:3])
+                if len(memory.context.files_involved) > 3:
+                    files_str += f" (+{len(memory.context.files_involved) - 3} more)"
+                context_parts.append(f"Files: {files_str}")
+
+            if memory.context.languages:
+                context_parts.append(f"Languages: {', '.join(memory.context.languages)}")
+
+            if memory.context.frameworks:
+                context_parts.append(f"Frameworks: {', '.join(memory.context.frameworks)}")
+
+            if memory.context.technologies:
+                context_parts.append(f"Technologies: {', '.join(memory.context.technologies)}")
+
+            if memory.context.git_branch:
+                context_parts.append(f"Branch: {memory.context.git_branch}")
+
+            if context_parts:
+                context_text = "\n**Context:**\n" + "\n".join(f"  {part}" for part in context_parts)
+                memory_text += "\n" + context_text
+
+        return CallToolResult(
+            content=[TextContent(type="text", text=memory_text)]
+        )
+    except KeyError as e:
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Missing required field: {e}"
+            )],
+            isError=True
+        )
+    except Exception as e:
+        logger.error(f"Failed to get memory: {e}")
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Failed to get memory: {e}"
+            )],
+            isError=True
+        )
+
+
+async def handle_update_memory(
+    memory_db: MemoryDatabase,
+    arguments: Dict[str, Any]
+) -> CallToolResult:
+    """Handle update_memory tool call.
+
+    Args:
+        memory_db: Database instance for memory operations
+        arguments: Tool arguments from MCP call containing:
+            - memory_id: ID of memory to update (required)
+            - title: New title (optional)
+            - content: New content (optional)
+            - summary: New summary (optional)
+            - tags: New tags list (optional)
+            - importance: New importance score (optional)
+
+    Returns:
+        CallToolResult with success message or error
+    """
+    try:
+        memory_id = arguments["memory_id"]
+
+        # Get existing memory
+        memory = await memory_db.get_memory(memory_id, include_relationships=False)
+        if not memory:
+            return CallToolResult(
+                content=[TextContent(
+                    type="text",
+                    text=f"Memory not found: {memory_id}"
+                )],
+                isError=True
+            )
+
+        # Update fields
+        if "title" in arguments:
+            memory.title = arguments["title"]
+        if "content" in arguments:
+            memory.content = arguments["content"]
+        if "summary" in arguments:
+            memory.summary = arguments["summary"]
+        if "tags" in arguments:
+            memory.tags = arguments["tags"]
+        if "importance" in arguments:
+            memory.importance = arguments["importance"]
+
+        # Update in database
+        success = await memory_db.update_memory(memory)
+
+        if success:
+            return CallToolResult(
+                content=[TextContent(
+                    type="text",
+                    text=f"Memory updated successfully: {memory_id}"
+                )]
+            )
+        else:
+            return CallToolResult(
+                content=[TextContent(
+                    type="text",
+                    text=f"Failed to update memory: {memory_id}"
+                )],
+                isError=True
+            )
+    except KeyError as e:
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Missing required field: {e}"
+            )],
+            isError=True
+        )
+    except Exception as e:
+        logger.error(f"Failed to update memory: {e}")
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Failed to update memory: {e}"
+            )],
+            isError=True
+        )
+
+
+async def handle_delete_memory(
+    memory_db: MemoryDatabase,
+    arguments: Dict[str, Any]
+) -> CallToolResult:
+    """Handle delete_memory tool call.
+
+    Args:
+        memory_db: Database instance for memory operations
+        arguments: Tool arguments from MCP call containing:
+            - memory_id: ID of memory to delete
+
+    Returns:
+        CallToolResult with success message or error
+    """
+    try:
+        memory_id = arguments["memory_id"]
+
+        success = await memory_db.delete_memory(memory_id)
+
+        if success:
+            return CallToolResult(
+                content=[TextContent(
+                    type="text",
+                    text=f"Memory deleted successfully: {memory_id}"
+                )]
+            )
+        else:
+            return CallToolResult(
+                content=[TextContent(
+                    type="text",
+                    text=f"Failed to delete memory (may not exist): {memory_id}"
+                )],
+                isError=True
+            )
+    except KeyError as e:
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Missing required field: {e}"
+            )],
+            isError=True
+        )
+    except Exception as e:
+        logger.error(f"Failed to delete memory: {e}")
+        return CallToolResult(
+            content=[TextContent(
+                type="text",
+                text=f"Failed to delete memory: {e}"
+            )],
+            isError=True
+        )