Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Graph Database Neo4J Cypher Expert

    1

    Design property graph models and write optimized Neo4j Cypher queries for fraud detection and recommendations.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Graph Database Neo4J Cypher Expert

    Graph Database Neo4J Cypher Expert

    Example session with this skill installed

    Model a fraud detection system for bank transfers and write a query to find circular paths of money between accounts.

    • Read your context and instructions
    • Compiled the graph database neo4j

    I have mapped the fraud detection domain to a property graph model and generated the Cypher queries to detect circular transfers. ## Neo4j Fraud Detection Model ```cypher // 1. Schema Constraints CREATE CONSTRAINT FOR (a:Account) REQUIRE a.accountId IS UNIQUE; // 2. Data Model Summary // Nodes: (:Account {accountId, riskScore}) // Relationships: [:TRANSFERRED_TO {amount, timestamp}] -> (:Account) // 3. Circular Path Detection (3 to 5 hops) // Finds money moving from an account back to itself through intermediaries MATCH path = (a:Account)-[:TRANSFERRED_TO*3..5]->(a) WHERE all(rel IN relationships(path) WHERE rel.amount > 1000) RETURN a.accountId AS StartingAccount, [n in nodes(path) | n.accountId] AS AuditTrail, reduce(s = 0, r IN relationships(path) | s + r.amount) AS TotalVolume, length(path) AS HopCount ORDER BY TotalVolume DESC LIMIT 10; // 4. High-Frequency Transfer Pattern MATCH (a:Account)-[r:TRANSFERRED_TO]->(b:Account) WITH a, b, count(r) AS transferCount, sum(r.amount) AS totalAmount WHERE transferCount > 5 RETURN a.accountId, b.accountId, transferCount, totalAmount; ``` **Next steps** 1. Apply the unique constraint to your `Account` nodes to optimize lookups. 2. Index the `timestamp` property on `TRANSFERRED_TO` relationships if you plan to filter by time windows. 3. Run `EXPLAIN` on the circular path query to verify the execution plan against your specific graph density.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Relational schemas fail when connections matter more than records. This skill designs property graph models and high-performance Cypher queries to navigate complex relationships without the join-heavy overhead of SQL. ## What it does - **Graph Modeling** defines domain entities as Nodes and directed Relationships with specific properties. - **Cypher Generation** writes declarative queries using `MATCH`, `WHERE`, and `RETURN` syntax. - **Traversal Optimization** structures paths to prevent Cartesian products and mitigate supernode expansion. - **Schema Enforcement** generates unique constraints and mandatory property requirements for data integrity. ## How it works 1. **Define Schema** by mapping your domain entities to labels and defining the directions of relationships. 2. **Generate Constraints** to ensure data quality and unique identifiers across nodes. 3. **Build Queries** for specific business logic like fraud detection or recommendation pathfinding. 4. **Refine Performance** by analyzing the traversal logic to ensure efficient graph lookups. ## Frameworks & tools Specifically designed for Neo4j and the Cypher query language. ## Why this beats prompting it yourself Writing Cypher requires a shift from set-based logic to path-based logic. This skill avoids common amateur mistakes like unintentional Cartesian products or neglecting index-backed constraints, ensuring queries scale as the graph grows. ## Use cases - **Fraud Detection** by identifying circular payment chains or shared account attributes. - **Recommendation Engines** using collaborative filtering through multi-hop relationship traversals. - **Identity Resolution** to link disparate data points into a single customer node. - **Knowledge Graphs** for mapping complex ontological relationships between entities. ## Known limitations Focuses exclusively on Neo4j and Cypher syntax. It does not generate Gremlin queries or handle non-graph database migrations.

    Focuses exclusively on Neo4j and Cypher syntax. Does not generate Gremlin queries or handle non-graph database migrations.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 2 days ago

    Requires

    File System Read/Write (strictly scoped to current project workspace `./`).
    Zero global installation or elevated privileges required.

    Permissions

    Read Files

    Target Use Cases: - Write a Cypher query in Neo4j to find shortest path. - Design a Neo4j property graph schema for recommendation engine. - Detect circular transaction loops in Neo4j with Cypher.

    Listed2 days ago

    What's inside

    Frequently Asked Questions

    Unlike SQL, which uses resource-heavy JOINs, this skill focuses on path-based logic to navigate millions of connections in milliseconds, making it ideal for fraud detection and complex recommendations.

    This skill is designed to work with any AI agent capable of executing or generating database queries, provided the agent has access to a Neo4j environment or a code execution sandbox.

    The skill provides optimized Cypher query structures, schema constraint definitions, and graph modeling strategies tailored specifically to Neo4j's property graph architecture.

    Yes, the skill is specifically programmed to avoid common Cypher pitfalls like Cartesian products and supernode bottlenecks, ensuring queries remain performant as your graph grows.

    This skill focuses exclusively on Neo4j and the Cypher query language; it does not support Gremlin, SPARQL, or other graph query languages at this time.

    New in Data & Databases