MCP Memento

Instructions

Implementation Reference

• src/memento/tools/search_tools.py:23-87 (handler)

  Implementation of the handle_search_mementos function which serves as the handler for the search_mementos MCP tool.

  @handle_tool_errors("search memories")
  async def handle_search_mementos(
      memory_db: SQLiteMemoryDatabase, arguments: Dict[str, Any]
  ) -> CallToolResult:
      """Handle search_memories tool call.
  
      Args:
          memory_db: Database instance for memory operations
          arguments: Tool arguments from MCP call containing:
              - query: Text search query (optional)
              - terms: Multiple search terms (optional)
              - memory_types: Filter by memory types (optional)
              - tags: Filter by tags (optional)
              - project_path: Filter by project path (optional)
              - min_importance: Minimum importance threshold (optional)
              - limit: Maximum results per page (default: 50)
              - offset: Number of results to skip for pagination (default: 0)
              - search_tolerance: Search mode (strict/normal/fuzzy, default: normal)
              - match_mode: Match mode for terms (any/all, default: any)
              - relationship_filter: Filter by relationship types (optional)
  
      Returns:
          CallToolResult with formatted search results or error message
      """
      # Validate input arguments
      validate_search_input(arguments)
  
      # Build search query
      search_query: SearchQuery = SearchQuery(
          query=arguments.get("query"),
          terms=arguments.get("terms", []),
          memory_types=[MemoryType(t) for t in arguments.get("memory_types", [])],
          tags=arguments.get("tags", []),
          project_path=arguments.get("project_path"),
          min_importance=arguments.get("min_importance"),
          limit=arguments.get("limit", 50),
          offset=arguments.get("offset", 0),
          search_tolerance=arguments.get("search_tolerance", "normal"),
          match_mode=arguments.get("match_mode", "any"),
          relationship_filter=arguments.get("relationship_filter"),
      )
  
      paginated_result = await memory_db.search_memories(search_query)
  
      if not paginated_result.results:
          return CallToolResult(
              content=[
                  TextContent(
                      type="text", text="No memories found matching the search criteria."
                  )
              ]
          )
  
      # Format results
      results_text: str = f"Found {len(paginated_result.results)} memories (total: {paginated_result.total_count}):\n\n"
      for i, memory in enumerate(paginated_result.results, 1):
          results_text += f"**{i}. {memory.title}** (ID: {memory.id})\n"
          results_text += f"Type: {memory.type.value} | Importance: {memory.importance}\n"
          results_text += f"Tags: {', '.join(memory.tags) if memory.tags else 'None'}\n"
          if memory.summary:
              results_text += f"Summary: {memory.summary}\n"
          results_text += "\n"
  
      return CallToolResult(content=[TextContent(type="text", text=results_text)])