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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Graph RAG > Department and Skills Graph - Finding Experts Across Teams

Department and Skills Graph - Finding Experts Across Teams

Author: Venkata Sudhakar

ShopMax India has departments spread across multiple cities - Engineering in Bangalore, Logistics in Mumbai, Customer Support in Chennai, and Sales in Delhi and Hyderabad. Each employee brings different technical and domain skills. When a new product feature requires React and payment integration expertise, the HR and tech leads need to quickly find who across all departments has those skills. Neo4j models employees, departments, and skills as separate node types connected by relationships, making cross-department expert discovery a simple graph traversal.

The graph uses three node labels: Employee, Department, and Skill. Relationships include WORKS_IN (employee to department) and HAS_SKILL (employee to skill) with an optional proficiency property. To find experts in a skill, match all employees with a HAS_SKILL edge to the target Skill node. To find all skills in a department, traverse WORKS_IN in reverse to collect employees, then follow HAS_SKILL to aggregate skills. Neo4j returns results without needing joins because relationships are direct pointers between nodes.

The example below creates ShopMax India departments, employees, and skills, then runs two queries: find all employees with Python expertise and their departments, then find all unique skills available in the Engineering department.

from neo4j import GraphDatabase

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

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

def setup_graph(session):
    session.run("MATCH (n) DETACH DELETE n")
    session.run("""
    CREATE (eng:Department {name: "Engineering", city: "Bangalore"})
    CREATE (ops:Department {name: "Logistics", city: "Mumbai"})
    CREATE (sup:Department {name: "Support", city: "Chennai"})
    CREATE (e1:Employee {id: "E001", name: "Priya Nair"})
    CREATE (e2:Employee {id: "E002", name: "Amit Verma"})
    CREATE (e3:Employee {id: "E003", name: "Ravi Kumar"})
    CREATE (e4:Employee {id: "E004", name: "Meena Das"})
    CREATE (python:Skill {name: "Python"})
    CREATE (java:Skill {name: "Java"})
    CREATE (sql:Skill {name: "SQL"})
    CREATE (react:Skill {name: "React"})
    CREATE (e1)-[:WORKS_IN]->(eng)
    CREATE (e2)-[:WORKS_IN]->(eng)
    CREATE (e3)-[:WORKS_IN]->(ops)
    CREATE (e4)-[:WORKS_IN]->(sup)
    CREATE (e1)-[:HAS_SKILL {level: "Expert"}]->(python)
    CREATE (e1)-[:HAS_SKILL {level: "Advanced"}]->(java)
    CREATE (e2)-[:HAS_SKILL {level: "Advanced"}]->(python)
    CREATE (e2)-[:HAS_SKILL {level: "Expert"}]->(react)
    CREATE (e3)-[:HAS_SKILL {level: "Intermediate"}]->(python)
    CREATE (e3)-[:HAS_SKILL {level: "Expert"}]->(sql)
    CREATE (e4)-[:HAS_SKILL {level: "Advanced"}]->(sql)
    """)

def find_skill_experts(session, skill_name):
    result = session.run("""
    MATCH (emp:Employee)-[s:HAS_SKILL]->(skill:Skill {name: $skill})
    MATCH (emp)-[:WORKS_IN]->(dept:Department)
    RETURN emp.name AS employee, dept.name AS department, s.level AS level
    ORDER BY s.level
    """, skill=skill_name)
    return [record.data() for record in result]

def find_dept_skills(session, dept_name):
    result = session.run("""
    MATCH (emp:Employee)-[:WORKS_IN]->(dept:Department {name: $dept})
    MATCH (emp)-[s:HAS_SKILL]->(skill:Skill)
    RETURN DISTINCT skill.name AS skill, collect(emp.name) AS employees
    ORDER BY skill.name
    """, dept=dept_name)
    return [record.data() for record in result]

with driver.session() as session:
    setup_graph(session)
    print("Python experts across ShopMax India:")
    for r in find_skill_experts(session, "Python"):
        emp = r.get("employee", "")
        dept = r.get("department", "")
        level = r.get("level", "")
        print("  " + emp + " (" + dept + ") - " + level)

print()
    print("Skills available in Engineering:")
    for r in find_dept_skills(session, "Engineering"):
        skill = r.get("skill", "")
        employees = r.get("employees", [])
        print("  " + skill + ": " + ", ".join(employees))

driver.close()

It gives the following output,

Python experts across ShopMax India:
  Ravi Kumar (Logistics) - Intermediate
  Amit Verma (Engineering) - Advanced
  Priya Nair (Engineering) - Expert

Skills available in Engineering:
  Java: ['Priya Nair']
  Python: ['Priya Nair', 'Amit Verma']
  React: ['Amit Verma']

In production, add a full-text index on Skill.name to support fuzzy searches like 'Python' matching 'Python 3' or 'PySpark'. Store proficiency levels as integers (1-5) in addition to labels so you can filter by minimum level. Use relationship properties like endorsedBy or certifiedDate to track skill credibility. For ShopMax India with thousands of employees, this graph-based skills registry eliminates the need for a separate HR skills management tool and lets the tech hiring team query it directly via the Neo4j Browser or REST API.

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