openCypher | Specification of the Cypher property graph query language

I have a graph on Neptune and I used OpenCypher to query on it.

At the middle of the graph I have a big connected nodes, at the edges you can see that I have some single nodes/ nodes that connected only to 1-5 other nodes. (see on the picture)

I want to get all of them, there is an option to do so?

I tried to think about options like take a random Id from the center and check all the nodes that don't have a path from them to this node, or maybe say get a table with all nodes and number of connected nodes to them, and ask for all nodes that not contain more than 10 nodes connected

but I didn't find a way to write this query, Must to know that opencypher on Neptune not contains all the magic keys like 'all' predicate function, so need to find a way with the functions that neptune support

We use Neo4j AuraDB for our graph database but there we have issues with data upload. So, we decided to move to AWS Neptune using the migration tool.

We have 3.7M nodes and 11.2M relations in our database. The DB instance is db.r5.large with 2 CPUs and 16GiB RAM.

The same AWS Neptune OpenCypher queries are much slower than AuraDB Cypher queries (about 7-10 times slower). Also, we tried to rewrite the queries to Gremlin and test performance but it is still very slow. We have node and lookup indexes on AuraDB but we can't create them on AWS Neptune as it handles them automatically.

Is there any way to reach better performance on AWS Neptune?

UPDATE:

Example of Gremlin query: g.V().hasLabel('Member').has('address', eq('${address}')).outE('HAS').as('member_has').inV().as('token').hasLabel('Token').inE('HAS').as('other_member_has').outV().as('other_member').hasLabel('Member').where(__.select('member_has').where(neq('other_member_has'))).select('other_member', 'token').group().by(__.select('other_member').local(__.properties().group().by(__.key()).by(__.map(__.value())))).by(__.fold().project('member', 'number_of_tokens').by(__.unfold().select('other_member').choose(neq('cypher.null'), __.local(__.properties().group().by(__.key()).by(__.map(__.value()))))).by(__.unfold().select('token').count())).unfold().select(values).order().by(__.select('number_of_tokens'), desc).limit(20)

Example of Cypher query: MATCH (member:Member { address: '${address}' })-[:HAS]->(token:Token)<-[:HAS]-(other_member:Member) RETURN PROPERTIES(other_member) as member, COUNT(token) AS number_of_tokens ORDER BY number_of_tokens DESC LIMIT 20

I'm trying to run a MERGE query against an AWS Neptune database using their new OpenCypher implementation but MERGE is not yet supported as a clause.

Is there a way to get the behaviour of a MERGE without using a MERGE in Neptune's OpenCypher implementation?

I'm hoping it's possible to do something like:

I'm looking for a graph exploration tool similar to https://github.com/prabushitha/gremlin-visualizer for querying AWS Neptune while using openCypher to enjoy the new offering:
https://aws.amazon.com/blogs/database/announcing-opencypher-for-amazon-neptune-building-better-graph-applications-with-opencypher-and-gremlin-together/.
I'm familiar with the Jupyter notebook https://github.com/aws/graph-notebook but I'm looking for other alternatives.

I recently picked up Neo4j as it seemed the best type of database to store data I'm currently scraping off a number of online discussion forums. The primary structure of the graph is Community -> Forum -> Thread -> Post -> Author

I'm trying to write the Cypher queries to resolve GraphQL queries, and would like to paginate (for example) the Forum -> Thread connection. The relationship is CONTAINS which holds an order property i.e. (f:Forum)-[:CONTAINS]->(t:Thread)

From the neo4j-graphql-js library I picked up on their usage of pattern comprehension to run an "inner query" on the child nodes. For example: