Cypher

Cypher uses an ASCII-art syntax to express graph patterns visually. Instead of writing procedural traversal logic, you describe the structure you want to find, and the query engine optimizes the retrieval.

• Nodes are represented with parentheses: (p:Person)
• Relationships are drawn with arrows: -[r:KNOWS]->
• A complete pattern looks like: (a:Person)-[:KNOWS]->(b:Person)-[:LIVES_IN]->(c:City)

This declarative approach separates what to retrieve from how to retrieve it, allowing the Cypher planner to use cost-based optimization for efficient execution.

Cypher is purpose-built for the Property Graph Model, where both nodes and relationships can hold arbitrary key-value properties. This enables rich, expressive queries that filter on metadata directly within traversal patterns.

• Node properties: MATCH (c:Case {jurisdiction: 'Federal'})
• Relationship properties: MATCH (a)-[r:CITES {weight: 'majority'}]->(b)
• Variable-length paths: MATCH (a)-[:APPEALS_TO*2..5]->(b) finds chains of 2 to 5 appeals

For legal knowledge graphs, this allows modeling citation networks with metadata like court level, date, and treatment status directly on edges.

Unlike read-only query languages, Cypher supports full Create, Read, Update, Delete (CRUD) operations on graph structures. This makes it suitable for both analytical queries and transactional graph construction.

• CREATE: CREATE (s:Statute {name: 'CFAA', section: '1030'})
• MERGE: Ensures a pattern exists without duplication—critical for idempotent knowledge graph construction
• SET/REMOVE: Modify properties on existing nodes and relationships
• DETACH DELETE: Remove nodes along with all their incident relationships

This mutability is essential for building and maintaining evolving legal knowledge graphs that must incorporate new case law and statutory amendments.

Cypher supports aggregation functions and list comprehensions that enable complex analytical queries over graph structures without requiring external processing.

• Aggregation: count(), collect(), avg(), min(), max() operate over matched subgraphs
• List comprehension: [x IN nodes(path) WHERE x:Precedent | x.name] filters and transforms inline
• Path functions: shortestPath(), allShortestPaths() find optimal routes through legal citation networks
• WITH clause: Enables pipeline-style query composition, passing intermediate results between query segments

For legal reasoning, this enables queries like "find the most-cited precedent within a 3-hop radius of this statute" in a single expression.

Cypher includes DDL-style commands for enforcing data integrity and optimizing query performance through explicit indexing and constraint creation.

• Uniqueness constraints: CREATE CONSTRAINT FOR (c:Case) REQUIRE c.citation IS UNIQUE
• Node key constraints: Ensure a combination of properties uniquely identifies a node
• Existence constraints: Require specific properties on nodes or relationships
• Index types: B-tree, full-text, and vector indexes for hybrid semantic + structural search

These features are critical for legal knowledge graphs where citation integrity and entity disambiguation are non-negotiable requirements.

Modern Cypher (openCypher 9+) supports subqueries through CALL blocks, enabling modular query design and complex multi-stage graph analytics within a single statement.

• CALL subqueries: Execute a nested query and union results with the outer scope
• Post-union processing: Apply additional filters and aggregations after combining subquery results
• Existential subqueries: Test for pattern existence without returning data: EXISTS { MATCH (a)-[:OVERRULES]->(b) }

This composability allows legal engineers to build modular reasoning pipelines—for example, first identifying relevant precedents, then filtering by jurisdictional authority, then ranking by citation frequency.