Cypher Query Language

Cypher uses an ASCII-art syntax to visually describe graph patterns. Instead of writing procedural traversal logic, you declare the structure you want to find.

• Nodes are represented by parentheses: (p:Person)
• Relationships are represented by arrows and square brackets: -[:KNOWS]->
• The pattern (a:Person)-[:KNOWS]->(b:Person)-[:KNOWS]->(c:Person) finds friend-of-a-friend connections

This declarative approach allows the query planner to optimize execution strategy independently of the query's expression, often resulting in more efficient traversals than hand-coded graph algorithms.

Cypher is designed for the labeled property graph model, which provides a rich, intuitive way to model real-world domains.

• Nodes can have multiple labels (e.g., :Person:Employee) and store arbitrary key-value properties
• Relationships are first-class citizens with a type, direction, and their own properties (e.g., -[:PURCHASED {date: '2024-01-15'}]->)
• This model eliminates the need for complex join tables and allows relationships to carry metadata about the connection itself

The property graph model maps naturally to object-oriented domain models, reducing the impedance mismatch common with relational databases.

Cypher provides a rich set of clauses for both querying and modifying graph data in a single, composable syntax.

• MATCH: Finds patterns in the graph, analogous to SELECT in SQL
• WHERE: Filters results with predicates and boolean expressions
• RETURN: Projects and shapes the result set, supporting aggregation with functions like count(), avg(), and collect()
• CREATE / MERGE: Creates new nodes and relationships; MERGE acts as an upsert, ensuring a pattern exists without duplication
• SET / REMOVE: Updates properties and labels on existing graph elements
• DELETE / DETACH DELETE: Removes nodes and relationships, with DETACH DELETE automatically removing all connected relationships

These clauses can be chained together, allowing complex multi-step graph mutations in a single query.

Cypher natively supports variable-length relationships, enabling queries that traverse paths of unknown or arbitrary depth without recursive common table expressions.

• The syntax -[:KNOWS*1..5]-> matches paths between 1 and 5 hops
• -[:KNOWS*]-> matches paths of any length
• Shortest path queries use the built-in shortestPath() function: MATCH p = shortestPath((a:Person)-[:KNOWS*]-(b:Person))

This capability is fundamental for use cases like social network analysis, supply chain tracing, and dependency resolution, where the depth of the relationship chain is not known in advance.

Cypher supports functional programming patterns for transforming collections and paths directly within queries.

• List comprehensions: [x IN nodes(path) WHERE x.age > 30 | x.name] filters and transforms node lists
• Pattern comprehensions: [(p:Person)-[:LIVES_IN]->(c:City) | c.name] evaluates a pattern and returns a custom list
• Predicate functions: all(), any(), none(), and single() test conditions across list elements
• UNWIND: Expands a list into individual rows, enabling batch operations and list-to-row transformations

These functional constructs reduce the need for post-processing in application code and keep complex data transformations within the database engine.

The WITH clause acts as a pipeline operator, chaining subqueries together by passing results from one part of a query to the next.

• It functions like a combination of SQL's WITH (CTE) and SELECT, allowing you to aggregate, filter, and reshape data mid-query
• Enables multi-part graph analytics: MATCH (p:Person)-[:PURCHASED]->(item) WITH p, count(item) AS purchases WHERE purchases > 5 MATCH (p)-[:LIVES_IN]->(city) RETURN p.name, city.name, purchases
• Essential for controlling cardinality and scoping variables in complex traversals

WITH is the mechanism that transforms Cypher from a simple pattern matcher into a powerful data pipeline language capable of expressing multi-stage analytical workflows.

The algorithmic foundation underlying Cypher's MATCH clause. Traversal strategies include:

• Breadth-First Search (BFS): Explores all neighbors at current depth before going deeper
• Depth-First Search (DFS): Follows a path to its end before backtracking Cypher abstracts traversal complexity, but understanding variable-length relationships like (a)-[*2..5]->(b) requires knowing how the engine walks edges. Critical for multi-hop reasoning in knowledge graphs.

The NLP task of converting natural language into executable logical forms like Cypher queries. A system receiving 'Who worked with Alice on Project X?' must parse it into:

codeCopy
MATCH (a:Person {name:'Alice'})-[:COLLABORATED_ON]->(p:Project {name:'X'})<-[:COLLABORATED_ON]-(c:Person)
RETURN c.name

This bridges LLMs and knowledge graphs, enabling Text-to-Cypher capabilities central to Graph RAG architectures.

Systems that answer natural language questions by querying a structured knowledge graph. Cypher serves as the execution layer in property graph-based KGQA pipelines. The architecture typically involves:

• Entity linking to map question mentions to graph nodes
• Relation classification to identify predicate types
• Query construction to generate Cypher from the parsed intent
• Answer extraction from returned graph patterns Critical for building hallucination-resistant AI systems with deterministic factual grounding.