Standards
7 min

How to Migrate from a Property Graph to a Knowledge Graph

Key takeaways

  • The trigger is usually a second consumer the model could not travel to.
  • Four layers move, in increasing difficulty: nodes and edges, identity, semantics, constraints.
  • Decide the URI scheme before moving anything. Changing it later means rewriting every reference.
  • Declaring the constraints almost always finds data that violated them silently for years.
In this article
Share

Why would you migrate from a property graph to a knowledge graph?

Usually because a second consumer appeared and the model could not travel to it.

A property graph is a sound choice for a connected-data problem inside one application. The migration question arises when the model stops being an implementation detail. A second system needs the same entities. An auditor asks what a classification meant last year. A regulator wants to see the rule that produced an answer.

At that point the property graph is doing its job and the organization needs something it was never built to carry. Identity that survives leaving the database, semantics a machine can reason over, and constraints expressed as reviewable data. RDF vs property graphs covers that trade in detail.

What actually has to move?

Four layers, and they get harder in order.

LayerDifficultyWhy
Nodes and edgesEasyA mechanical transform. Every product exports this
IdentityModerateLocal keys become global identifiers, and you must decide the scheme
SemanticsHardMeaning encoded in labels and application code has to be made explicit
ConstraintsHardestRules live in procedural code and have to be rediscovered before they can be declared

Teams budget for the first layer and are surprised by the fourth. The constraints are the real work, because they were never written down as constraints. They exist as validation scattered through an application, and finding them means reading code and interviewing the people who wrote it.

How do you handle identity?

Decide the URI scheme before you move a single node, and treat that decision as permanent.

A property graph identifies things by internal keys that mean something only inside that database. The migration replaces those with globally resolvable identifiers, and the scheme you choose will outlive several platforms. Changing it later means rewriting every reference held by every consumer.

Decisions to settle up front

  • The namespace. A domain you control and will keep. Avoid anything tied to a product or a team name.
  • Opaque or readable identifiers. Readable ones help humans and tempt people to parse them. Opaque ones are safer and harder to debug.
  • What gets an identifier. Concepts certainly, relationships sometimes, instances usually not at first.
  • The mapping back. Keep the original key as a property so you can reconcile during the transition.

That last point makes a staged migration possible. With the old key retained, both systems can run in parallel and you can verify that the new model answers the same questions before anything is switched off.

Should you convert everything at once?

No, and the attempt is the commonest way this goes badly.

A big-bang conversion produces a faithful translation of the old model, including every modelling compromise that was made for the old engine. You arrive with the same shape in a new technology and none of the properties you migrated for, because nobody revisited the semantics.

The alternative is to move the contested parts first. Take the entities that two systems disagree about, model those properly with explicit semantics and declared constraints, and leave the rest in place. The property graph keeps serving its application. The governed layer holds the handful of concepts that needed to travel.

Most organizations find that the list of concepts genuinely needing migration is a fraction of the model, and discovering that early saves a quarter.

What does a staged migration look like?

Six steps, and the fourth is where the value shows up.

A sequence that works

  • Inventory the contested entities. Which concepts does a second system need, and where do the two disagree today?
  • Fix the identity scheme and mint identifiers for those concepts only.
  • Make the semantics explicit. What a label meant implicitly becomes a stated relationship with a definition.
  • Recover the constraints. Read the validation code, write the rules down, declare them in SHACL, then run them against real data and expect failures.
  • Run both in parallel and reconcile answers until they agree for the right reasons.
  • Point the second consumer at the governed layer and leave the property graph serving its original application.

Step four is where the value surfaces. Declaring the rules almost always finds data that violated them silently for years, and that finding is usually worth the migration on its own.

What goes wrong during the move?

Four failures, and three of them are avoidable by deciding something earlier than feels necessary.

Failures to plan around

  • The identity scheme changes mid-migration. Somebody realises the namespace was wrong, and every reference minted so far has to be reissued. Settle it in week one and write down why.
  • The old model is translated faithfully. Every compromise made for the previous engine arrives intact, and the semantics were never revisited. This looks like a successful migration and delivers nothing.
  • Constraints are declared from the specification. The spec says what the rules were meant to be. The code says what they are. Declare from the code, then reconcile the difference as a finding.
  • Parallel running is skipped. Without it there is no way to show the new model answers the same questions, so the cutover becomes an act of faith.

The third is the one that produces the most interesting output. Specification and behaviour diverge in every long-lived system, and the gap between them is usually a list of decisions somebody made quietly and never recorded.

Do you end up running both?

Frequently, and that is a sound outcome.

The property graph continues doing traversal at volume for the application it was built for. The governed layer holds the agreed meaning that several systems depend on. They are connected by mappings maintained as data, and somebody owns those mappings.

Treating the migration as an either-or decision forces a choice that the architecture does not require, and usually ends with the governed model living inside the operational store where it quietly becomes unportable again. Types of graphs maps where each tier sits.

So what should I take away?

Migrate the concepts that need to travel and leave the rest. Fix the identity scheme first and treat it as permanent. Expect the constraints to be the hard part, because they were never written down.

TopQuadrant does this work with enterprises and the pattern is consistent. The data moves in days. The semantics take weeks. The constraints take longer than anyone budgeted and find real problems while they are being recovered. Our knowledge graph platform holds the result in open standards, so the next migration is a move instead of a rewrite.

Give your AI the context it's been missing

See how the TQ Data Foundation turns your enterprise knowledge into trusted, Al-ready context.