	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Graph RAG > Finding Reporting Chains and Management Trees in Neo4j

Finding Reporting Chains and Management Trees in Neo4j

Author: Venkata Sudhakar

ShopMax India's HR team frequently needs to answer questions like: who are all the managers above a given employee, or how many people report to a VP across all levels? These traversal queries are trivial in Neo4j but require complex recursive CTEs in SQL. By storing the employee graph with REPORTS_TO relationships, ShopMax India can find complete management chains upward from any employee and all subordinates downward from any manager with a single Cypher pattern.

Cypher's variable-length relationship syntax [:REPORTS_TO*1..10] matches paths of 1 to 10 hops. Traversing upward means following REPORTS_TO from the employee node toward the root; traversing downward means matching employees who have a REPORTS_TO path leading to the target manager. The length(path) function returns the number of hops, which indicates whether a report is direct (level 1), skip-level (level 2), or deeper. Results can be ordered by level to show the chain in sequence.

The example below uses the org chart created in the previous tutorial. It finds the full management chain above Divya Pillai (a developer in Bangalore) and then lists all employees under Priya Nair (VP Engineering) grouped by their reporting level.

from neo4j import GraphDatabase

URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password")

driver = GraphDatabase.driver(URI, auth=AUTH)

def get_management_chain(session, employee_name):
    result = session.run("""
    MATCH path = (emp:Employee {name: $name})-[:REPORTS_TO*1..10]->(mgr:Employee)
    RETURN mgr.name AS manager, mgr.role AS role, length(path) AS hops
    ORDER BY hops
    """, name=employee_name)
    return [record.data() for record in result]

def get_all_reports(session, manager_name):
    result = session.run("""
    MATCH path = (emp:Employee)-[:REPORTS_TO*1..10]->(mgr:Employee {name: $name})
    RETURN emp.name AS name, emp.role AS role, length(path) AS level
    ORDER BY level, emp.name
    """, name=manager_name)
    return [record.data() for record in result]

with driver.session() as session:
    print("Management chain above Divya Pillai:")
    for r in get_management_chain(session, "Divya Pillai"):
        hops = r.get("hops", 0)
        manager = r.get("manager", "")
        role = r.get("role", "")
        print("  Level " + str(hops) + ": " + manager + " (" + role + ")")

print()
    print("All reports under Priya Nair (any depth):")
    for r in get_all_reports(session, "Priya Nair"):
        level = r.get("level", 0)
        name = r.get("name", "")
        role = r.get("role", "")
        label = "Direct" if level == 1 else "L" + str(level)
        print("  [" + label + "] " + name + " (" + role + ")")

driver.close()

It gives the following output,

Management chain above Divya Pillai:
  Level 1: Sneha Iyer (Eng Manager)
  Level 2: Priya Nair (VP Engineering)
  Level 3: Arjun Sharma (CTO)

All reports under Priya Nair (any depth):
  [Direct] Kiran Rao (Eng Manager)
  [Direct] Sneha Iyer (Eng Manager)
  [L2] Amit Verma (Senior Dev)
  [L2] Divya Pillai (Developer)

In production, add an upper bound to the hop count (e.g. *1..15) to prevent runaway traversals on circular data. Use the shortestPath() function when you only need the direct reporting chain rather than all paths. For large organizations with thousands of employees, Neo4j handles traversal efficiently because relationships are stored as direct pointers - no index scan needed. Also consider storing a precomputed depth property on each Employee node to speed up level-based filters without traversal.

Send your comments, suggestions or queries regarding this site to [email protected].