AI curriculum

Course outline for Knowledge Graph Engineering

Build a graph that answers useful relationship questions. Choose entity identities, model edges, load a graph database, and write multi-hop queries. Resolve duplicates without silently merging ambiguous entities. Make ingestion repeatable and maintain source-qualified assertions through correction and retirement.

Knowledge Graph Engineering Course Objectives

  • Design a graph model around concrete relationship questions.
  • Operate Neo4j and write Cypher reads and updates from basics.
  • Enforce available key constraints and test identities independently.
  • Resolve exact duplicates and hold ambiguous entity matches for review.
  • Implement repeatable ingestion with rejected and quarantined records.
  • Run useful multi-hop queries with explicit relationship semantics.
  • Correct and retire assertions while preserving current and historical views.

Pre-requisites

  • Basic data modeling, simple queries, and Python data transformations.
  • Knowledge Engineering Foundations for AI Systems or equivalent entity, relationship, identity, and provenance concepts.
  • Basic database-selection knowledge; a focused bridge introduces missing terms.
  • No previous Cypher, Neo4j, RDF, or formal ontology course is required.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Recommended preparation

Readiness checks

  • Basic data modeling, simple queries, and Python data transformations.
  • Knowledge Engineering Foundations for AI Systems or equivalent entity, relationship, identity, and provenance concepts.
  • Basic database-selection knowledge; a focused bridge introduces missing terms.
  • No previous Cypher, Neo4j, RDF, or formal ontology course is required.

Basic data modeling, simple queries, and Python data transformations.

Find your place in the learning map

Lab Setup

Delivery requirements: the environment, access, and exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.

Disposable Neo4j Community instance, compatible Python driver, Cypher client, relational exports, ingestion starter, and tests. Database and driver practice starts with a visible write/read. Delivery requires verified stable versions, edition-specific constraints, authentication, license, resource limits, persistence, and cleanup. Prepared connection/IO scaffolding leaves identity and recovery logic to the learner. No hosted service, production records, or model account is required.

Detailed Course Outline

Module 1: Shape the graph around its questions (2 hours)

  • Property graph foundations: Property graphs, nodes, relationships, labels, and properties.
  • Question-driven modeling: Query-driven modeling versus copying every source table.
  • Graph identity and vocabulary: Stable keys, entity identity, edge direction, and relationship vocabulary.
  • Neo4j operation: Neo4j basics: connect, create records, inspect, and persist.
  • Edition-specific constraints: Constraints supported by the selected edition and independent validation.
  • Relational alternatives: Relational joins versus graph traversal and maintenance cost.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Populate a first graph and justify its model using two relationship questions.

Module 2: Retrieve useful paths with Cypher (2 hours)

  • Cypher patterns: MATCH patterns, WHERE, RETURN, parameters, and result rows.
  • Bounded path queries: Multi-hop relationships, path limits, and cycle-aware questions.
  • Query result checks: Aggregation, duplicate results, missing relationships, and query checks.
  • Relationship meanings: Dependency, temporal, ownership, and causal relationships as different meanings.
  • Query plan inspection: Query plans and bounded inspection without production performance claims.
  • Independent expected sets: Learner-authored queries compared with independently prepared expected sets.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Answer dependency and ownership questions without interpreting connectivity as causation.

Module 3: Resolve identity before making connections (2 hours)

  • Source identity rules: Source keys, normalization, exact matches, and candidate match rules.
  • Ambiguous matches: Namesakes, changed labels, incomplete records, and ambiguous matches.
  • Reviewed merges: Review queues, explicit merge decisions, and retained source mappings.
  • Assertion evidence: Assertion identities and source evidence for individual relationships.
  • Pre-insertion validation: Candidate validation and rejection before graph insertion.
  • False-merge correction: False-merge consequences and correction boundaries.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Resolve exact duplicates while preserving an ambiguous namesake as an unresolved candidate.

Module 4: Make graph construction repeatable (2 hours)

  • Python driver and transactions: Python driver basics, parameterized writes, and transaction boundaries.
  • Ingestion accounting: Node-first ingestion, relationship loading, and rejected-record accounting.
  • MERGE and uniqueness: MERGE behavior, uniqueness, and stable source/assertion keys.
  • Interrupted-load recovery: Reruns, source corrections, and partial-load recovery.
  • Set reconciliation: Input/output reconciliation beyond unchanged aggregate counts.
  • Ingestion failure tests: An actual ingestion script with learner-authored failure tests.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Run ingestion twice and recover an interrupted load without duplicate accepted identities.

Module 5: Keep current answers and historical evidence (2 hours)

  • Source-qualified assertions: Assertion records with source, status, validity, and recorded time.
  • Supersession and retirement: Supersession, retirement, and current-view selection policies.
  • Source conflict: Conflicting sources without duplicate unqualified truth claims.
  • Historical views: Historical queries and affected-path regression checks.
  • Maintenance and deletion: Maintenance ownership, deletion policy, and source changes.
  • Graph usefulness: Bounded graph usefulness versus another authoritative data store.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Correct one claim and query both the current result and retained source history.

Practical exercise

  • Build a component-and-maintainer graph from synthetic relational exports. Load components, versions, maintainers, and dependency assertions into actual Neo4j. Author Cypher queries for indirect dependencies, responsible maintainers, and the source supporting a selected path. Use bounded path lengths and inspect duplicates. Give every relationship type a defined meaning.
  • Implement Python ingestion with stable source keys and explicit transactions. Test an exact duplicate, ambiguous namesake, unsupported relation, missing endpoint, and partial interruption. Rerun the script and check actual key sets, relationship sets, rejected records, and query answers, not merely matching total counts. MERGE does not replace a uniqueness policy or solve concurrent identity resolution.
  • Represent source-qualified claims as assertion records where necessary rather than pretending a bare edge can hold conflicting histories unambiguously. Correct one dependency and retire another assertion. Preserve prior evidence and query current and historical views under a documented cutoff policy. Maintain at least one unresolved source conflict. Predict a new query result before opening feedback. No actual model extraction is claimed by the supplied candidate records.

Delivery and timing

  • Guided hours include teaching, demonstrations, learner practice, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite setup are additional. Allocations need a timed learner pilot before delivery; they are not measured completion times.

What you will produce

Build and query a Neo4j graph with repeatable ingestion, reviewed identities, and source-qualified history.

How the work is checked

  • The graph model answers its intended questions with stable identities.
  • Actual Cypher queries return independently checked multi-hop results.
  • Ambiguous matches do not become automatic merges.
  • Repeated and interrupted ingestion preserves the expected key and edge sets.
  • Rejected input accounts for unsupported or incomplete relationships.
  • Current and historical results correctly reflect correction and retirement.
  • Provenance and path order are not presented as proof of causation.

10 guided hours. A real Neo4j property graph and actual Python ingestion are required. Edition-specific constraints, persistence, failure recovery, and cleanup need verification. This is not simultaneous RDF mastery, full bitemporal engineering, or production concurrent-ingestion certification. Retain an ordinary relational store when its joins meet the need with less complexity.

When another approach is better

  • Use relational joins when graph traversal does not improve the workload enough to justify another store.
  • Do not automate entity merges when available evidence cannot establish identity.

How we train

Contact us for full course details, including duration, delivery options and lab requirements.

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals