Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 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

    // 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.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Data & Databases.

    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 buying a skill.

    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

    Software
    Zero global installation
    orelevated privileges required.

    File System Read/Write (strictly scoped to current project workspace `./`).

    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