Contents
  1. Purpose
    1. When explicit structure earns its cost
      1. Match the representation to the task
  2. Representation
    1. Entities, relations, and graph instances
    2. Schemas constrain; ontologies interpret
    3. Must-know turning points
  3. Identity and claims
    1. Identity decisions shape every neighborhood
    2. Relationships need their context
  4. Construction
    1. Extraction proposes; acceptance publishes
      1. Acceptance is a separate transition
    2. Every assertion needs a paper trail
  5. Query and evidence
    1. Patterns bind; traversals expand
    2. A connected path is not proof
    3. Graphs complement search and generation
  6. Lifecycle and decision
    1. Corrections must propagate without erasing history
    2. Test each layer, then choose the representation
      1. Claims require different checks
  7. Check understanding
  8. Open questions
  9. Selected talks
  10. References
  11. Talk library
← All topics

Knowledge graphs

A knowledge graph represents identifiable things and the relationships between them. Connecting a person, a project and a service across separate records makes it possible to ask questions that a document-by-document lookup cannot answer directly. The useful structure depends on getting identities, relation meanings and dates right. This chapter explains how to build, query and maintain those connections, and when their benefits justify the work beyond ordinary search.

Purpose

When explicit structure earns its cost

A knowledge graph represents selected entities and typed relationships as data that programs can inspect and query. It earns this extra structure when an application repeatedly needs the same identity-aware joins, relationship constraints, or multi-step connections. A support system, for example, may need to connect a ticket to the affected component, the component to an exact deployed artifact, and that artifact to its dependencies. Search can locate passages mentioning those objects; a graph can make the chosen identities and connections reusable across many questions.

Documents remain the natural authority when wording, surrounding argument, or newly encountered concepts matter most. Relational tables remain strong when the domain already has stable records, keys, constraints, and known joins; recursive SQL can even implement graph-shaped traversal. Search indexes are useful when candidate ranking matters more than exhaustive structural matching. A graph database is therefore a storage and query choice, not a prerequisite for connected data and not a replacement for source documents.

Match the representation to the task

Task propertyUsually useful starting pointWhy
Exact source wording and narrative contextDocuments plus searchThe document remains the object being interpreted.
Stable records, constraints, and known joinsRelational dataKeys and declarative joins already express the contract.
Repeated traversal through named relationshipsGraph or relational graph modelIdentity and path structure become reusable query inputs.
Ranked discovery over changing textLexical or vector searchRanking semantics matter more than exact pattern matching.
Source-faithful evidence plus repeated relationship questionsHybrid document–graph systemDocuments preserve evidence; the graph indexes curated identities and relations.
New concepts arrive faster than curationDocuments and search; add structure selectivelyA rapidly changing graph can cost more to maintain than its relationships are reused.
Qualified claims and provenance are essentialExplicit claim tables, a deliberately modeled graph, or a hybridPreserve participants, occurrence context and source lineage in the chosen model.
No owner for identity and schema decisionsPrefer existing contracts and keep graph scope narrowUnmaintained structure loses its apparent precision over time.

The strongest adoption evidence compares the graph with the credible simpler alternative on the same tasks. One LinkedIn customer-service study reported higher retrieval rank for its graph-based system than its text-retrieval comparison, while a separate production comparison found shorter median resolution time for the complete tool than manual work. Those results concern a particular ticket structure, system, and workflow; they neither isolate graph structure as the sole cause nor establish a universal advantage.

Representation

Entities, relations, and graph instances

An entity is a distinguishable thing in the modeled domain: a person, organization, software component, document, event, or concept. An attribute is a value describing an entity or relationship. A relation is a typed claim connecting participants, such as component depends on package. Direction matters: A depends on B does not mean B depends on A. Stable identifiers let several records refer to the same chosen entity even when their display names change. Minsky’s frames (June 1974 memo) represented familiar situations through slots, conditions and revisable defaults. Those defaults were expectations, not verified assertions.

The Resource Description Framework (RDF) represents a statement as a subject–predicate–object triple. A subject may be an Internationalized Resource Identifier (IRI) or a blank node; a predicate is an IRI; and an object may be an IRI, a blank node, or a literal value. Reusing an IRI connects statements into a graph. A property graph instead uses nodes, typed directed edges, labels, and properties on nodes or edges. These models can express similar domain claims, but their structural units and ways of attaching metadata differ.

Suppose a source states that package web-framework@4.2 depends on common-util@2.1. RDF can encode two resources connected by a dependsOn predicate and attach version values in additional triples. A property graph can use two Package nodes and a DEPENDS_ON edge. In either form, the graph records an assertion made under a modeling contract. It does not prove that the dependency inventory is complete, current, or correct.

Schemas constrain; ontologies interpret

A graph schema specifies the structures an implementation accepts or describes: node or entity types, relationship types, property datatypes, permitted endpoint directions, keys, and sometimes cardinalities. Angles and colleagues’ PG-Schema (2023) distinguishes prescriptive schemas, which constrain modifications, from descriptive schemas, which report existing structure, and partial schemas, which enforce only stable portions. A schema can therefore be both a contract and a discovery surface, but those are different operating modes.

An ontology gives domain categories and relationships explicit meaning and may include axioms from which a reasoner derives further statements. In Web Ontology Language (OWL) semantics, declaring teaches to have domain Teacher means that observing Bob teaches Scooter entails that Bob is a Teacher. This is not a database constraint that rejects an untyped Bob; it is a rule for deriving a type. Likewise, a declared transitive relation supports composition only when that relation's domain meaning truly is transitive.

The Shapes Constraint Language (SHACL) checks selected RDF nodes against declared constraints, reporting missing values or wrong datatypes without modifying the graph. Conformance and entailment do not verify identities or premises.

OWL also commonly uses an open-world assumption: failure to find a statement does not entail its negation. If the graph lacks a birth date, the date is unknown to that graph—not necessarily nonexistent. An application shape can nevertheless require that date: requirements and entailments answer different questions. In the application example, a shape explicitly targets Bob and requires a staffIdentifier value; it need not wait for class inference to choose that focus node.

One assertion, two independent questions

Shared asserted dataBob teaches ScooterNo staffIdentifier value is recorded for Bob.

Validation branch

Application constraint

:StaffShape a sh:NodeShape ;
sh:targetNode :Bob ;
sh:property [
  sh:path :staffIdentifier ;
  sh:minCount 1
] .

Explicit focus node Bob + asserted data → SHACL validation

ReportMissing required staffIdentifier value.

Entailment branch

Domain axiom

:teaches rdfs:domain :Teacher .

Teaching assertion + domain axiom → reasoning

Entailed statementBob rdf:type Teacher
Bob is explicitly targeted for validation. Independently, the teaching assertion and domain axiom entail his Teacher type. Both retain the asserted triple: a missing required value is neither a false domain claim nor a truth check.

Must-know turning points

Knowledge graphs combine traditions that developed in parallel: conceptual representation, logical data independence, reusable domain knowledge, interoperable descriptions and construction from imperfect sources.

Traditions combined in knowledge graphs

  1. 1967Quillian’s semantic networkOrganized conceptual associations for programmatic search and comparison.Sources & context

    Contributors: Quillian

    What changed: The paper Word Concepts described a running program that searched dictionary-derived networks to compare meanings and express conclusions.

  2. June 1970Codd’s relational modelSeparated logical relations from physical organization and access paths.Sources & context

    Contributors: E. F. Codd

    What changed: A Relational Model of Data for Large Shared Data Banks established a continuing alternative for explicit relationships, declarative operations, and consistency—not a lineage displaced by graphs.

  3. 1977 implementationKL-ONEGave concepts, roles, inheritance, and instantiation more precise semantics.Sources & context

    Contributors: Brachman and Schmolze, authors of the 1985 overview

    What changed: The retrospective reports the first implementation in 1977. It distinguishes describing a category from asserting that a particular individual exists.

  4. March 15, 1985 paperCycProposed reusable commonsense knowledge to address brittle AI systems.Sources & context

    Contributors: Douglas Lenat, Mayank Prakash, and Mary Shepherd

    What changed: The paper argued that scaling learning, programming, and language understanding required substantial real-world knowledge, while identifying knowledge acquisition as a major burden.

  5. 1985 project startWordNetMade lexical concepts and typed semantic relationships directly addressable.Sources & context

    Contributors: Princeton; report authors Miller, Beckwith, Fellbaum, Gross, and Miller

    What changed: Synonym sets represent concepts rather than alphabetical entries. The supplied report describes the 1990 system and was revised in August 1993; 1985 identifies the project start.

  6. February 22, 1999 RecommendationRDFProvided a domain-neutral model for exchanging machine-processable descriptions.Sources & context

    Contributors: W3C

    What changed: The Recommendation distinguished its data model from XML interchange syntax. Domain meaning was supplied through schemas, supporting exchange between independently developed applications.

  7. July 27, 2006 noteLinked DataConnect publishers through identifiers, HTTP lookup and cross-dataset links.Sources & context

    Contributors: Tim Berners-Lee

    What changed: The personal Design Issues note described an explorable Web of data, not a W3C Recommendation. The supplied version records a later June 2009 revision.

  8. 2007 paperDBpediaExtract structured Wikipedia content into connected RDF descriptions.Sources & context

    Contributors: DBpedia research team

    What changed: The paper mapped infoboxes and other structures into queryable data while noting contradictory sources and extraction errors. An article link alone did not express a specific domain relation.

  9. 2008 paperFreebasePresented a collaboratively maintained, application-facing knowledge commons.Sources & context

    Contributors: Bollacker, Evans, Paritosh, Sturge, and Taylor

    What changed: The SIGMOD paper described a general-knowledge tuple database with public read/write access through an HTTP graph-query API.

  10. 2014 paperKnowledge VaultCombined noisy extraction channels with repository priors through probabilistic fusion.Sources & context

    Contributors: Dong and colleagues

    What changed: Presented at KDD, the system assigned probabilities to candidate facts instead of treating automatically extracted triples as accepted truth.

Notice the differing contributions: conceptual structure, logical data independence, reusable knowledge, interchange, collaboration, and probabilistic construction. These are parallel traditions, not a causal chain. Spacing is not to scale.

Wider exchange increases the opportunity for reuse while exposing contradictions, extraction errors and uncertain identity. Common identifiers and a shared data model do not resolve those construction problems.

The traditions remain complementary. Formal semantics can clarify a modeling contract; extraction can propose broader coverage; probabilistic scores can guide review. Each still requires an explicit acceptance and maintenance policy.

Identity and claims

Identity decisions shape every neighborhood

Entity resolution decides whether records or mentions denote the same entity. A scalable pipeline usually first generates plausible candidate pairs, then evaluates evidence such as identifiers, normalized attributes, context, and disagreement. Probabilistic record linkage compares how likely observed agreements are among true matches versus nonmatches; agreement on a rare value is generally stronger evidence than agreement on a common one. The result may be a link, a non-link, or an unresolved case requiring more evidence.

Candidate generation must be evaluated separately from match classification. If blocking excludes a true pair, no later matcher can recover it. Let the eligible pair universe be UU, true matching pairs be TT, and generated candidates be CC. Candidate recall is ∣C∩T∣/∣T∣|C\cap T|/|T|; its denominator includes true pairs outside the candidate set. Measuring only scored candidates hides precisely those misses.

A false merge combines neighborhoods that belong to different entities, contaminating traversals and inherited attributes. A false split leaves one entity represented by several nodes and hides connections. Final clusters can imply record pairs that were never directly scored, so cluster evaluation must inspect all within-cluster pairs rather than only accepted comparison edges. Pairwise quality and exact recovery of complete entities answer different questions.

Identity grouping changes the query neighborhood

Query seed: r1. Collect product claims from all source records in r1’s canonical identity group. Outlined groups represent identity decisions; each record’s product claim stays attached to that record.

Correct identity

r1 reports product → Bearings

r2 reports product → Seals

r3 reports product → Valves

Reachable from r1Bearings, Seals

False merge

r1 reports product → Bearings

r2 reports product → Seals

r3 reports product → Valves

Reachable from r1Bearings, Seals, Valves

False split

r1 reports product → Bearings

r2 reports product → Seals

r3 reports product → Valves

Reachable from r1Bearings

In this fictional fixture, r1 and r2 denote V1, while r3 denotes distinct vendor V2. Only the canonical grouping changes. A false merge adds Valves; a false split hides Seals, without editing either source claim.

Repair must be reversible. Wikidata's documented unmerge procedure restores both pre-merge items and warns that downstream references may also require correction. Preserve source records, match evidence, the chosen canonical identity, and unresolved alternatives instead of destructively replacing them with one display name. For the broader distinction between content similarity and identity, see Duplicates depend on identity.

Relationships need their context

A binary edge is sufficient when a relation truly has two participants and no consequential occurrence-specific details. Direction, inverse meaning, and symmetry must still be explicit. Package A depends on Package B is directional; Person A collaborates with Person B may be modeled symmetrically; Person A manages Team B may have a separately named inverse. These choices determine which paths queries can follow.

When dates, roles, quantities, product scope, jurisdiction, source, or confidence belong to a particular occurrence, the relationship needs an attachment point. The W3C's n-ary relation pattern represents the relationship as its own instance connected to participants and qualifiers. Two supply arrangements between the same companies can then retain different products, dates, and sources instead of collapsing into one undifferentiated supplies edge.

Shared participants, separate qualifier bundles

Each arrangement owns its product, observation date and sourceSupplier SCustomer CArrangement r1product: BearingsobservedOn: 2026-01-10source: Report AArrangement r2product: SealsobservedOn: 2026-02-10source: Report Bsuppliercustomersuppliercustomer

Possible lossy projection: S supplies C. A chosen mapping could produce this binary statement; the relation-instance pattern does not automatically entail it.

Fictional supplier terms apply the W3C relation-instance pattern. Each product, observation date and source belongs to exactly one occurrence. Observation is not contract validity; relation instances are not automatically RDF reification.

RDF reification can describe a realization of a triple through subject, predicate, and object fields. Importantly, reifying a triple does not assert the triple, and asserting the triple does not create its reification. Property graphs can attach properties to an edge, while an event or relation node can work in either broader modeling style. These alternatives differ in query shape, identity, and portability; none automatically supplies trustworthy provenance.

Extraction must also preserve linguistic qualifications. Negation, possibility, attribution, and quantities can change the meaning of an otherwise identical subject–relation–object triple. MinIE's published examples show affirmative, negative, and uncertain sentences yielding the same underlying relation with different annotations. Dropping those annotations turns distinct claims into false agreement.

Construction

Extraction proposes; acceptance publishes

Graph construction begins with source acquisition and representation. Structured records often already expose fields and keys that can be mapped into nodes and relations. Unstructured documents require mention detection, entity linking, relation extraction, and preservation of document structure. A useful document-derived graph keeps lexical objects—documents, sections, chunks, and mention locations—separate from domain entities so an extracted assertion can still be traced to its source context.

A domain schema reduces uncontrolled variation. Instead of asking a model for arbitrary triples, an extractor can be asked for known entity types, relation types, units, and fields. A recipe extractor, for example, can distinguish recipes, ingredients, quantities, steps, and techniques. Structured output makes proposed records more consistent and queryable, but even a strong prompt can misidentify an entity, normalize a unit incorrectly, or invent a relation.

Treat extraction as proposal generation. Normalize identifiers and values under explicit rules; validate; resolve or defer ambiguous identities; and apply task-specific review before publication. Preserve rejected and unresolved proposals when they are useful for diagnosing systematic errors. General questions about whether a source is fit and permitted belong to Origins, times and permitted use; this pipeline owns the graph-specific decision about what becomes an assertion.

Acceptance is a separate transition

Illustrative pseudocode

Python-like pseudocode
def consider(candidate, source):
    normalized = normalize(candidate)
    structural = validate_schema(normalized)
    if not structural.conforms:
        return Rejected(normalized, structural.report, source)

    identity = resolve_entities(normalized)
    if identity.is_ambiguous:
        return Unresolved(normalized, identity.evidence, source)

    reviewed = review_assertion(identity.assertion, source)
    if not reviewed.accepted:
        return Rejected(identity.assertion, reviewed.reason, source)

    return Published(reviewed.assertion, provenance=source)

Every assertion needs a paper trail

Provenance records an asserted production history. The W3C PROV model distinguishes entities, activities, and responsible agents. A source revision is an entity; an extraction or review is an activity that uses inputs and generates outputs; software, a person, or an organization may bear responsibility. Derivation links a published assertion to the source and intermediate representations that affected it.

For a consequential assertion, retain the source identifier and immutable revision or content hash, source passage when available, acquisition time, transformation and software version, reviewer or responsible process, assertion status, and business-effective time when the domain uses one. Keep source time, retrieval time, generation time, and effective time distinct: generating a fresh summary from an old source does not make the underlying claim current.

Documents, sections and exact passages form a lexical structure; extraction and review activities form a production history. These support the domain assertions without being the same graph. Derived facts must remain connected to verbatim or otherwise faithful inputs. When two entities merge, the merged identity must preserve both source sets. When later evidence contradicts a relationship, invalidating the old assertion while recording the new evidence preserves why the visible state changed. A provenance graph walk makes inspection possible after lexical, vector, or relational retrieval, but inspectability still does not prove truth.

P1 denotes the same passage in both panels. Arrows in production history read from a record to its generating activity or source, not as chronological flow. Review accepts a candidate as A1 without changing source wording. The fictional domain claim remains distinct from its provenance; provenance establishes neither truth nor permission.

Provenance also does not confer permission. Derived summaries and graph artifacts can contain information from several restricted sources, so authorization must follow the contributing information into retrieval and generation. Broader responsibilities for lineage and authority are developed in Preserve origins and dependencies.

Query and evidence

Patterns bind; traversals expand

A graph query usually starts with a pattern. Variables bind to nodes, relationships, or values that satisfy specified labels, directions, types, and property predicates. This resembles a relational join: shared variables connect compatible bindings. The visual graph is not the query result; the result is a collection of variable bindings whose multiplicity depends on the query's semantics.

SPARQL evaluates graph patterns as multisets of solution mappings. Projection can hide variables without removing duplicates; DISTINCT explicitly deduplicates. OPTIONAL retains the left-side match if its optional pattern fails. In the comparison, moving the price filter outside removes B because 30 is not below 20, and C because comparing an unbound value produces an error.

A filter changes which partial matches survive

Fixed source fixtureA has price 10; B has price 30; C has no price assertion. All three are Items.

FILTER inside OPTIONAL

PREFIX ex: <https://example.invalid/>
SELECT ?item ?p WHERE {
  ?item a ex:Item .
  OPTIONAL {
    ?item ex:price ?p .
    FILTER (?p < 20)
  }
}
ORDER BY ?item
?item?p
A10
Bunbound
Cunbound

FILTER outside OPTIONAL

PREFIX ex: <https://example.invalid/>
SELECT ?item ?p WHERE {
  ?item a ex:Item .
  OPTIONAL { ?item ex:price ?p . }
  FILTER (?p < 20)
}
ORDER BY ?item
?item?p
A10
Inside OPTIONAL, B and C remain but ?p is unbound. Outside, B fails the comparison and C’s unbound comparison errors, so only A remains. B’s source price is still 30; unbound is neither zero nor an empty string.

Property-graph languages such as Cypher express similar ideas through node–relationship patterns and traversal. A selective indexed predicate can reduce starting rows before expansion. Variable-length expansion then follows eligible relationships, while later joins or Cartesian products can multiply intermediate bindings. The final answer may be small even when the plan explored many rows. Use plan estimates for hypotheses and measured operator rows for diagnosis.

Traversal requires an explicit boundary: allowed relationship types and directions, minimum and maximum hops, cycle policy, permitted endpoints, and termination conditions. Breadth-first and depth-first strategies explore in different orders; an end node and a terminator node have different effects. A depth-limited result is evidence about that bounded search, not proof of unrestricted reachability.

A connected path is not proof

A multi-hop result composes several assertions. Every edge brings its own identity decision, source, effective time, review status, and authorization conditions. If service uses artifact and artifact contains package are both current and correctly resolved, the path supports investigating the package's relationship to the service. It does not by itself establish that a reported vulnerability is exploitable; that requires a separate product-context assessment.

Navigation and logical inference must not be confused. Any two edges can form a navigable path. They license a derived relation only when a declared rule and the domain semantics justify composition. ancestorOf may be transitive; knows generally is not. OWL entailment follows supplied axioms, so an invalid premise or inappropriate axiom can still produce a formally valid but factually wrong consequence.

Edge confidence scores do not combine automatically. The probability that every premise is correct depends on conditional relationships among errors. Multiplying individual scores assumes an independence structure that copied sources, shared extractors, or one mistaken entity merge usually violate. Multiple paths may be correlated, contradictory, or different derivations of the same claim. Preserve the supporting subgraph and its alternatives instead of returning only a terminal entity or a single unsupported confidence number.

Graph context can nevertheless improve diagnosis. If an answer is wrong, the selected subgraph gives developers a concrete object to inspect for bad extraction, duplicate entities, stale edges, or overbroad traversal. That is explainability of the retrieval basis, not proof that the model's answer follows from it.

Graphs complement search and generation

Search and graph querying answer different kinds of question. Search ranks candidate documents, chunks, or entities under lexical or learned relevance signals. A graph pattern returns structured matches under explicit identity and relationship constraints. A hybrid system can use full-text or vector search to find seed nodes, expand through selected relationships, and rank the expanded candidates. The graph does not replace the search index; it provides another retrieval surface.

Graph-assisted retrieval is useful when a relevant fact is connected to a semantic match but is not independently similar to the question. In a news graph, for example, vector-matched paragraph nodes can lead to their articles, then through shared topics or organizations to other articles. Expansion must still be bounded and evaluated: every neighbor is reachable, not necessarily relevant. General index construction, ranking, freshness, and retrieval evaluation belong in Search and Retrieval.

GraphRAG names a family of retrieval-augmented generation systems that use graph-derived artifacts or traversal as part of context selection. Darren Edge and colleagues’ From Local to Global: A GraphRAG Approach to Query-Focused Summarization, first submitted on April 24, 2024, presents Microsoft’s approach. It extracts entities and relationships, creates hierarchical communities and summaries, and uses community reports for corpus-wide questions. Other systems begin with vector seeds and local neighbor expansion. These mechanisms answer different query classes and impose different indexing, provenance, and authorization burdens.

Before generation, authorize the selected derived artifacts, retain their source lineage, and serialize a bounded evidence package. Generated answers then have their own grounding, citation, and abstention obligations, covered in Retrieval-Augmented Generation. Graph construction, retrieval, context serialization, and answer generation are separate stages; success at one does not validate the others.

Blue and gold arrows show processing; plain labeled connectors show domain relationships. Local expansion must be bounded and ranked before assembling authorized context. Global requests use previously built community reports, with authorization before generating partial answers. These are application requirements, not automatic GraphRAG guarantees. Preserve source lineage for derived reports.

Lifecycle and decision

Corrections must propagate without erasing history

Graph maintenance starts by naming the change. A new source, corrected assertion, entity merge, entity split, expired relation, schema revision, and permission withdrawal affect different objects. Re-running extraction without classifying the event can duplicate assertions, preserve obsolete summaries, or destroy the history needed to explain a correction.

A bitemporal model separates valid time, when a fact applies in the modeled world, from system time, when a version became known to the database. A correction learned today can revise what was believed to apply last month while preserving the earlier database snapshot. Evaluations and historical queries must choose both cutoffs consistently; querying past valid time with current system knowledge can leak later corrections. The fictional supply arrangement was first recorded on February 1 as applying from January 1. An April 1 correction changes its valid start to March 1; both stored versions remain available.

Ask both when it applies and when it was known

Initial record selected.
01-0101-0102-0102-0103-0103-0104-0104-0105-0105-01System time ↑ (2026)Valid time → (2026)Initial recordCorrected record∞∞↑ ∞

Start dates are inclusive; end dates are exclusive. Both valid-time intervals extend beyond the plot. The corrected system-time interval also continues indefinitely.

Stored versionValid intervalSystem interval
Initial[2026-01-01, ∞)[2026-02-01, 2026-04-01)
Corrected[2026-03-01, ∞)[2026-04-01, ∞)
Change the cutoff, keep the historical question
Valid-time targetSystem cutoffResult
2026-01-152026-02-15Initial
2026-01-152026-04-15No assertion in this snapshot
2026-03-152026-04-15Corrected
Select a version only when both half-open interval predicates hold. Changing system time can change the answer about January without changing the historical February snapshot. Both records remain stored; no matching assertion is not a negative fact.

Retraction is not always deletion. If one source contribution is removed, an assertion may remain supported by another contribution or derivation. Incremental maintenance therefore tracks support separately from the visible assertion set. For derived facts, deletion must distinguish unsupported results from results with another proof. Cycles and equality make this harder, which is why source contribution counts should not be confused with logical derivation counts or confidence.

Derived artifacts require their own maintenance. Zep's documented behavior, for example, can preserve shared nodes and edges after one episode is deleted, while names or summaries may retain information from that episode. GraphRAG community reports similarly contain generated material derived from multiple sources. Updating the canonical edge is therefore not completion: affected indexes, embeddings, reports, caches, authorization metadata, and downstream consumers must be invalidated, regenerated, denied, or explicitly reconciled.

A change event shows that an update was published, not that every downstream consumer applied it. Verify the state exposed by each affected consumer after its documented synchronization mechanism runs; missing or unreadable source data should remain an error rather than being treated as proof of deletion. The broader change taxonomy appears in Maintain fitness through change, while deletion propagation is developed in Propagate correction and deletion.

Test each layer, then choose the representation

A knowledge graph has no single quality score. Schema conformance, referential integrity, entity resolution, extraction accuracy, provenance coverage, freshness, query correctness, authorization, and downstream usefulness are separate claims requiring distinct oracles. Pairwise resolution metrics cannot validate final clusters; a correct query result cannot show that its premises are current or permitted.

Claims require different checks

ClaimUseful checkWhat remains open
Instance follows structural contractSchema or shape validationIdentity, truth, completeness, and usefulness
Records were resolved correctlyLabeled pair and final-cluster evaluationUnlabeled population and downstream impact
Assertion is inspectableSource and derivation trace auditSource truth, authority, and permission
Query implements its contractFixture results plus plan inspectionPremise quality and production task value
Retrieved context supports the responseClaim-to-context assessmentReal-world correctness and source eligibility
Graph improves the workflowTask-matched baseline comparisonTransfer, recurring cost, and future drift

Evaluation units must stay visible. Retrieval precision and recall require a declared item type and relevance set; chunk numerators cannot be mixed with document denominators. Entity blocking needs truth labels outside the candidate set. Query performance requires intermediate rows and storage work, not only final result count. Downstream comparisons should hold the task population, consumer, permissions, and relevant system settings stable. Choose checks that match the requirement develops this oracle discipline.

Include maintenance in the comparison: identify who will review identity, evolve the schema, preserve provenance and propagate corrections. A representation that cannot be maintained under the real workload is not a successful implementation.

Choose the smallest representation that preserves the task's consequential distinctions. A graph is a strong candidate when stable identities, repeated relationship joins, semantic constraints, inspectable connected evidence, or localized corrections materially improve outcomes. Documents are stronger when exact wording and rapid ingestion dominate. Relational systems remain appropriate when known records and joins already express the domain. Many AI systems should be hybrid: documents remain canonical evidence, while a deliberately scoped graph indexes identities and relationships that have demonstrated reuse.

The final architecture must name owners for schema evolution, identity review, provenance, corrections, authorization, and consumer notification. If no one can maintain those contracts, the graph's apparent precision will decay into stale structure. If those contracts support demonstrably better tasks, however, the graph becomes more than a drawing: it becomes a maintained interface through which programs can inspect and use connected claims.

Open questions

  1. How can teams estimate the recurring cost of identity review, ontology evolution, provenance retention, and correction propagation before adopting a graph? Existing sources document particular workloads, not a portable total-cost model.

  2. How should permission withdrawal propagate through assertions, embeddings, community summaries, caches, and generated outputs with end-to-end completion evidence? Component mechanisms exist, but no implementation-independent protocol guarantees complete withdrawal.

  3. How large is the downstream effect of false merges and false splits under realistic graph workloads? Current evidence explains mechanisms, denominators, and repair procedures, but not a representative propagation magnitude.

  4. Can graph, relational, document, lexical, vector, and hybrid systems be compared on the same evolving tasks while holding semantic enrichment, consumer behavior, review labor, and authorization constant? Such a study would make architectural decisions substantially less anecdotal.

  5. How should uncertainty propagate through dependent assertions and alternative derivations without treating extractor scores as calibrated probabilities or independent evidence? Progress would require explicit dependency models, calibrated inputs, and evaluation against conclusions rather than isolated edges.

Follow the curated reading path through the speakers and demonstrations behind this entry.

Explore more talks

The rest of the library, beyond the curated path. Cited talks support this entry; reviewed transcripts were processed in full. Metadata candidates have not been reviewed as sources or verified as topic members.

52 matching talks

TalkSpeakerEventYear
Emil EifremAI Engineer World's Fair 20242024
Sam JulienAI Engineer World's Fair 20252025
Michael Hunger, Stephen Chin, Jesús BarrasaAI Engineer World's Fair 20252025
Your Moat Is Your Data Model

Transcript reviewed

Mike PhippsAI Engineer World's Fair 20262026
Mitesh PatelAI Engineer World's Fair 20252025
Emil EifremAI Engineer World's Fair 20262026
Jesús BarrasaAI Engineer World's Fair 20252025
Dr. Sajjan KanukolanuAI Engineer World's Fair 20262026
Stop Using RAG as Memory

Transcript reviewed

Daniel ChalefAI Engineer World's Fair 20252025
Intro to GraphRAG

Transcript reviewed

Zach BlumenfeldAI Engineer World's Fair 20252025
Zach BlumenfeldAI Engineer World's Fair 20252025
Andreas Kolleger, Zach Blumenthal, Michael Hunger, TomaszAI Engineer World's Fair 20242024
Stephen ChinAI Engineer Code 20252025
Kevin BaiAI Engineer World's Fair 20262026
Brandon WaselnukAI Engineer Europe 20262026
Zach Blumenfeld, Ben Squire, Ryan KnightAI Engineer World's Fair 20262026
Tom SmokerAI Engineer World's Fair 20252025
Vinoo GaneshAI Engineer World's Fair 20262026
Building security around ML

Transcript reviewed

Dr. Andrew DavisAI Engineer World's Fair 20242024
Peter Werry, BrandonAI Engineer Europe 20262026
Kobie CrawfordAI Engineer Europe 20262026
Stephen ChinAI Engineer World's Fair 20252025
Stephen Chin, Jonathan LoweAI Engineer Summit 20252025
Jonathan LarsonAI Engineer World's Fair 20252025
Ola MabadejeAI Engineer World's Fair 20252025
Yohei NakajimaAI Engineer World's Fair 20262026
Anita KirkovskaAI Engineer Summit 20252025
Varsha ShahAI Engineer World's Fair 20262026
Rachna SrivastavaAI Engineer World's Fair 20252025
Stephen ChinAI Engineer Europe 20262026
Andreas Kollegger, Zaid ZaimAI Engineer Europe 20262026
Anushrut GuptaAI Engineer World's Fair 20252025
Julia Neagu, Deanna Emery, Maitar AsherAI Engineer World's Fair 20252025
Andreas KolleggerAI Engineer World's Fair 20252025
Jaspreet SinghAI Engineer World's Fair 20252025
Chau TranAI Engineer World's Fair 20252025
Hubert MisztelaAI Engineer World's Fair 20242024
Mark Bain, Vasilije Markovic, Daniel Chalef, Alex GilmoreAI Engineer World's Fair 20252025
Elizabeth Fuentes LeoneAI Engineer World's Fair 20262026
Natalie MeurerAI Engineer World's Fair 20262026
Philip RathleAI Engineer World's Fair 20242024
Luis Romero-SevillaAI Engineer World's Fair 20262026
Nupur SharmaAI Engineer Europe 20262026
Subbiah Sethuraman, Abhilash AsokanAI Engineer World's Fair 20262026
Zach BlumenfeldAI Engineer Europe 20262026
Chin Keong LamAI Engineer World's Fair 20252025
Jeremy AdamsEvent unknownUnknown
Jordi SprangerAI Engineer NYC 2026 Online Talks2026
Gil FeigAI Engineer World's Fair 20262026
Cyrus ClarkeEvent unknownUnknown
Yoni Michael, Brandon CallenderAI Engineer World's Fair 20262026
Hrishi OlickelAI Engineer NYC 2026 Online Talks2026

References

Coverage and source review
Processed transcripts
26 processed in full · 5 in the curated path
Automated source review
Passed
Metadata candidates
31 unreviewed; not verified topic membership
Corpus version
1bd8e407b26a07b33815594e1b2db5f41827119a2b3cb6fbf240f9fc571fc767

Automated review checks source support; it is not publication approval.

A synthesis of selected conference talks and technical references. Citations link to the source material; they do not imply that every talk on this subject is included.

  1. Neo4j: Graph database concepts

    https://neo4j.com/docs/getting-started/appendix/graphdb-concepts/

  2. Software Dependencies — CycloneDX

    https://cyclonedx.org/use-cases/software-dependencies/

  3. A Relational Model of Data for Large Shared Data Banks

    https://research.ibm.com/publications/a-relational-model-of-data-for-large-shared-data-banks

  4. WITH Queries — PostgreSQL 18

    https://www.postgresql.org/docs/18/queries-with.html

  5. When Vectors Break Down: Graph-Based RAG for Dense Enterprise Knowledge

    https://www.youtube.com/watch?v=XlAIgmi_Vow&t=580

  6. Retrieval-Augmented Generation with Knowledge Graphs for Customer Service Question Answering

    https://arxiv.org/html/2404.17723v2

  7. RDF 1.1 Primer — W3C

    https://www.w3.org/TR/rdf11-primer/

  8. R2RML: virtual RDF over relational tables and joins

    https://www.w3.org/TR/r2rml/

  9. A Framework for Representing Knowledge

    https://www.mit.edu/~dxh/marvin/web.media.mit.edu/~minsky/papers/Frames/frames.html

  10. The Property Graph Database Model

    https://www.ceur-ws.org/Vol-2100/paper26.pdf

  11. The Knowledge Graph Mullet: Trimming GraphRAG Complexity

    https://www.youtube.com/watch?v=tYCu_57jzL8&t=283

  12. PG-Schema: Schemas for Property Graphs

    https://arxiv.org/abs/2211.10962

  13. OWL 2 Web Ontology Language Primer, Second Edition — W3C

    https://www.w3.org/TR/owl2-primer/

  14. Why Agentic Systems Need Ontologies

    https://www.youtube.com/watch?v=Sir59K8ZDPU&t=606

  15. Why Agentic Systems Need Ontologies

    https://www.youtube.com/watch?v=Sir59K8ZDPU&t=643

  16. Shapes Constraint Language (SHACL) — W3C

    https://www.w3.org/TR/shacl/

  17. Knowledge Graphs — extraction, integration, and completeness

    https://arxiv.org/html/2003.02320

  18. Word Concepts: A Theory and Simulation of Some Basic Semantic Capabilities

    https://cse.buffalo.edu/~rapaport/Papers/Papers.by.Others/quillian67.pdf

  19. An Overview of the KL-ONE Knowledge Representation System

    https://www.ciscl.unisi.it/lingcomp/doc/Brachman%20&%20Schmolze%201985%20-%20an%20overview%20of%20the%20KL-ONE%20Knowledge%20Representation%20System.pdf

  20. CYC: Using Common Sense Knowledge to Overcome Brittleness and Knowledge Acquisition Bottlenecks

    https://ojs.aaai.org/aimagazine/index.php/aimagazine/article/view/510/0

  21. Introduction to WordNet: An On-line Lexical Database

    https://wordnetcode.princeton.edu/5papers.pdf

  22. Resource Description Framework Model and Syntax Specification

    https://www.w3.org/TR/1999/REC-rdf-syntax-19990222/

  23. Linked Data — Design Issues

    https://www.w3.org/DesignIssues/LinkedData

  24. DBpedia: A Nucleus for a Web of Open Data

    https://www.cis.upenn.edu/~zives/research/dbpedia.pdf

  25. Freebase: a collaboratively created graph database for structuring human knowledge

    https://research.google/pubs/freebase-a-collaboratively-created-graph-database-for-structuring-human-knowledge/

  26. Knowledge Vault: A Web-Scale Approach to Probabilistic Knowledge Fusion

    https://research.google/pubs/knowledge-vault-a-web-scale-approach-to-probabilistic-knowledge-fusion/

  27. The Gremlin Graph Traversal Machine and Language

    https://arxiv.org/abs/1508.03843

  28. The Fellegi-Sunter model — Splink

    https://moj-analytical-services.github.io/splink/topic_guides/theory/fellegi_sunter.html

  29. Leveraging Unlabeled Data to Scale Blocking for Record Linkage

    https://www.ijcai.org/Proceedings/11/Papers/369.pdf

  30. Splink evaluation tutorial: labeled pairs and threshold selection

    https://moj-analytical-services.github.io/splink/demos/tutorials/07_Evaluation.html

  31. ER-Evaluation: clustering metrics and evaluation coverage

    https://er-evaluation.readthedocs.io/en/latest/er_evaluation.metrics.html

  32. Help:Merge — Wikidata

    https://www.wikidata.org/wiki/Help:Merge

  33. Build the AI GTM Agent That Knows the Buyer Before the First Message

    https://www.youtube.com/watch?v=ltv-L5oMPIs&t=834

  34. Defining N-ary Relations on the Semantic Web

    https://www.w3.org/TR/swbp-n-aryRelations/

  35. RDF 1.1 Semantics — W3C

    https://www.w3.org/TR/rdf11-mt/

  36. PROV-O: The PROV Ontology — W3C

    https://www.w3.org/TR/prov-o/

  37. MinIE: Minimizing Facts in Open Information Extraction

    https://aclanthology.org/D17-1278.pdf

  38. GraphRAG: The Marriage of Knowledge Graphs and RAG

    https://www.youtube.com/watch?v=knDDGYHnnSI&t=889

  39. Why Your Agent’s Brain Needs a Playbook: Practical Wins from Using Ontologies

    https://www.youtube.com/watch?v=CbiR9xS2skQ&t=193

  40. PROV-DM: The PROV Data Model

    https://www.w3.org/TR/prov-dm/

  41. A Practitioner's Guide to Graphs - Tim Ainge, Good Collective

    https://www.youtube.com/watch?v=3ySF0I5iE_0&t=222

  42. A Practitioner's Guide to Graphs - Tim Ainge, Good Collective

    https://www.youtube.com/watch?v=3ySF0I5iE_0&t=274

  43. W3C PROV-DM: The PROV Data Model

    https://www.w3.org/TR/prov-dm/

  44. W3C PROV-DM: Evidence Entities and Derivations

    https://www.w3.org/TR/prov-dm/

  45. PROV-DM: The PROV Data Model

    https://www.w3.org/TR/prov-dm/

  46. Time in XTDB

    https://docs.xtdb.com/about/time-in-xtdb.html

  47. Citation Needed: Provenance for LLM-Built Knowledge Graphs

    https://www.youtube.com/watch?v=H7puB0RwJMM&t=20

  48. Citation Needed: Provenance for LLM-Built Knowledge Graphs

    https://www.youtube.com/watch?v=H7puB0RwJMM&t=316

  49. Citation Needed: Provenance for LLM-Built Knowledge Graphs

    https://www.youtube.com/watch?v=H7puB0RwJMM&t=294

  50. GraphRAG output schemas

    https://microsoft.github.io/graphrag/index/outputs/

  51. GraphRAG global search

    https://microsoft.github.io/graphrag/query/global_search/

  52. PROV-DM: The PROV Data Model

    https://www.w3.org/TR/prov-dm/

  53. SPARQL 1.1 Query Language — W3C

    https://www.w3.org/TR/sparql11-query/

  54. Operators in detail — Neo4j

    https://neo4j.com/docs/cypher-manual/current/planning-and-tuning/operators/operators-detail/

  55. Statistics and execution plans — Neo4j

    https://neo4j.com/docs/operations-manual/current/performance/statistics-execution-plans/

  56. Understanding query plans — Neo4j

    https://neo4j.com/docs/cypher-manual/current/planning-and-tuning/execution-plans/

  57. Expand Paths with Config — APOC

    https://neo4j.com/docs/apoc/current/graph-querying/expand-paths-config/

  58. Images — Kubernetes

    https://kubernetes.io/docs/concepts/containers/images/

  59. Vulnerability Exploitability eXchange — CycloneDX

    https://www.cyclonedx.org/capabilities/vex/

  60. Deployment API Reference — Kubernetes

    https://kubernetes.io/docs/reference/kubernetes-api/apps/deployment-v1/

  61. Introduction to Probability — Conditional probability and the chain rule

    https://www.probabilitycourse.com/chapter1/1_4_0_conditional_probability.php

  62. Introduction to Probability — Independence

    https://www.probabilitycourse.com/chapter1/1_4_1_independence.php

  63. Maintaining Views Incrementally

    https://sigmodrecord.org/?download_id=9412&smd_process_download=1

  64. CrabRAG: Why Automated Assistants Need Graph Memory, Not More Tokens

    https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=666

  65. Practical GraphRAG: Making LLMs Smarter with Knowledge Graphs

    https://www.youtube.com/watch?v=XNneh6-eyPg&t=985

  66. The Knowledge Graph Mullet: Trimming GraphRAG Complexity

    https://www.youtube.com/watch?v=tYCu_57jzL8&t=577

  67. CrabRAG: Why Automated Assistants Need Graph Memory, Not More Tokens

    https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=625

  68. Practical GraphRAG: Making LLMs Smarter with Knowledge Graphs

    https://www.youtube.com/watch?v=XNneh6-eyPg&t=148

  69. From Local to Global: A GraphRAG Approach to Query-Focused Summarization

    https://arxiv.org/html/2404.16130v2

  70. HybridRAG: A Fusion of Graph and Vector Retrieval to Enhance Data Interpretation

    https://www.youtube.com/watch?v=-tgQa8Fzf80&t=239

  71. The Life of an Entity — Backstage

    https://backstage.io/docs/features/software-catalog/life-of-an-entity/

  72. Deleting Data from the Graph — Zep

    https://help.getzep.com/deleting-data-from-the-graph

  73. PostgreSQL INSERT: conflict handling and returned insertions

    https://www.postgresql.org/docs/18/sql-insert.html

  74. Combining Rewriting and Incremental Materialisation Maintenance for Datalog Programs with Equality

    https://www.cs.ox.ac.uk/isg/tools/RDFox/2015/IJCAI/FullPaper/paper.pdf

  75. Document-level access control — Azure AI Search

    https://learn.microsoft.com/en-us/azure/search/search-document-level-access-overview

  76. Introduction to Information Retrieval: evaluation of unranked retrieval sets

    https://nlp.stanford.edu/IR-book/html/htmledition/evaluation-of-unranked-retrieval-sets-1.html

  77. Ragas Faithfulness

    https://docs.ragas.io/en/stable/concepts/metrics/available_metrics/faithfulness/

  78. The Gene Ontology Knowledgebase in 2026

    https://escholarship.org/content/qt20v234dt/qt20v234dt_noSplash_475c0c1035b0ac4880d714f679ab0ab7.pdf

  79. OBO Foundry Principle 19: Stability of Term Meaning

    https://obofoundry.org/principles/fp-019-term-stability.html

  80. The Knowledge Graph Mullet: Trimming GraphRAG Complexity

    https://www.youtube.com/watch?v=tYCu_57jzL8&t=217

  81. Why Agentic Systems Need Ontologies

    https://www.youtube.com/watch?v=Sir59K8ZDPU&t=380