Knowledge Graphs: Connecting Entities and Relationships Across Sources

References

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

   Neo4j’s property-graph model stores entities as nodes and connects them through typed, directed relationships. Nodes can have labels; both nodes and relationships can carry properties. This makes a relationship such as a person working for an organization explicit and allows attributes to live on the connection. The model differs from RDF’s triple representation, although both support connected data. Choosing a graph database is a storage and query decision, separate from deciding what entities and relationships mean.

2. Software Dependencies — CycloneDX

   CycloneDX connects inventory components through bom-ref identifiers, which need only be unique within their BOM. A dependency object's ref identifies the dependent component; dependsOn lists its dependencies. The published example has Acme Application depending on web-framework and persistence, both depending on common-util, providing two paths to one transitive dependency. An explicitly empty dependency list denotes no dependencies; omission from the dependency graph can mean dependencies are unknown. Application inference: preserve BOM identity when importing locally scoped references, and distinguish missing inventory from an explicitly dependency-free component.

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

   E. F. Codd’s June 1970 paper proposed representing shared data as n-ary relations so applications could remain independent of physical organization and access paths. It addressed limitations of tree and network database models and applied relational operations to redundancy and consistency. This establishes relational systems as a continuing alternative lineage for explicit relationships, declarative queries, and constraints rather than merely a predecessor displaced by graph databases.

4. WITH Queries — PostgreSQL 18

   Recursive SQL can follow relationships stored in ordinary tables and retain visited identifiers as a path. PostgreSQL's CYCLE clause records cycle detection and the traversal path; simply replacing UNION ALL with UNION may not terminate recursion when changing depth values keep rows distinct. SEARCH computes ordering information rather than prescribing execution visitation order. An outer LIMIT is not a reliable production work bound: sorting or joining can require the recursive output to be fully fetched. These mechanisms establish a relational implementation option for graph-shaped tasks.

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

   The described implementation retained graph structure while storing its representation as JSON in a Lucene-based search engine.

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

   LinkedIn modeled ticket sections as trees and connected tickets through explicit issue links and separately identified title-similarity links. Construction combined rules with template-guided LLM parsing. An offline comparison using GPT-4 and E5 in both systems reported mean reciprocal rank of 0.927 versus 0.522 for conventional text retrieval. A separate production experiment randomly divided support staff between the complete tool and traditional manual work; median issue-resolution time was five versus seven hours.

7. RDF 1.1 Primer — W3C

   RDF represents statements as subject–predicate–object triples. Reusing the same resource in multiple statements connects those triples into a graph; IRIs identify resources and predicates, while literals represent values. Shared vocabularies give relationship names a common meaning. Turtle, JSON-LD, and other syntaxes can serialize the same graph without changing its logical content. Graph identity and consistent vocabulary are therefore central to joining information; a graph drawing is only a view of the data.

8. R2RML: virtual RDF over relational tables and joins

   R2RML maps a logical table (table, SQL view or query) to RDF through a subject map and predicate-object maps. A processor may expose virtual SPARQL access to the existing database instead of materializing a graph copy. Illustratively, EMP(emp_id,dept_id) contains (7,10), while DEPT(dept_id) contains (10). Map EMP using rr:tableName "EMP" and subject template "https://example.org/employee/{emp_id}"; map DEPT using "https://example.org/department/{dept_id}". An EMP predicate-object map with predicate :department, rr:parentTriplesMap referencing DEPT, and rr:joinCondition [rr:child "dept_id"; rr:parent "dept_id"] joins the records and emits <https://example.org/employee/7> :department <https://example.org/department/10>. Stable identifiers require stable, unique keys and a consistent IRI template; changing a display name need not change identity. Null key values do not generate an IRI from that template.

9. A Framework for Representing Knowledge

   Minsky proposed frames as structured representations of familiar situations, with slots for particular participants or values, conditions on those slots, and default expectations that could be displaced. Related frames shared information across different views or situations. The proposal addressed the limitations of treating knowledge as isolated fragments and explicitly distinguished expectations from details warranted by the current situation.

10. The Property Graph Database Model

    Renzo Angles formally defines a property graph as finite nodes and edges with directed incidence, labels, and properties on either nodes or edges. The proposed schema identifies node types, edge types, property datatypes, and permitted edge types between pairs of node types. Schema-instance consistency checks labels, datatypes, and allowed endpoint directions; additional constraints can express mandatory properties, uniqueness, and cardinality. The paper therefore separates a property-graph instance, its schema, its integrity constraints, and its query language.

11. The Knowledge Graph Mullet: Trimming GraphRAG Complexity

    The described Dgraph architecture combines property graph modeling and querying with RDF interchange and triples as the smallest record unit.

12. PG-Schema: Schemas for Property Graphs

    Angles and colleagues’ 2023 PG-Schema paper distinguishes prescriptive schemas that limit modifications, descriptive schemas that report what existing data contains, and partial schemas that enforce stable portions while describing evolving portions. The authors found fragmented schema support across eleven inspected property-graph engines and proposed formal property-graph types and key constraints as input to future standardization. This supports treating schema enforcement, schema discovery, and flexible ingestion as different operating contracts.

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

    OWL distinguishes individuals, classes, and properties and assigns logical meaning to axioms. A subclass relation can entail additional class membership. Domain and range assertions infer types from a relationship rather than acting like a database constraint that merely rejects an untyped record. Under the open-world assumption, a missing fact is not automatically false. Different names also do not automatically denote different individuals; identity or inequality can be asserted explicitly. These choices explain why ontology reasoning and SHACL validation answer different questions about the same data.

14. Why Agentic Systems Need Ontologies

    RDFS domain, range, and class relationships can derive types that were not explicitly stated in an individual relationship.

15. Why Agentic Systems Need Ontologies

    A declared transitive relationship allows a reasoner to derive an additional relationship from a chain of existing ones.

16. Shapes Constraint Language (SHACL) — W3C

    SHACL validates an RDF data graph against a shapes graph that declares constraints on selected focus nodes and their values. Constraints can check such properties as datatype and cardinality, and validation produces explicit results describing violations. Validation does not mutate the data or shapes graph. This gives a graph ingestion pipeline a way to check structural expectations separately from extracting statements or reasoning over them. A graph can conform to all declared shapes while still containing false or outdated claims.

17. Knowledge Graphs — extraction, integration, and completeness

    Named entity recognition locates entity mentions in text, typically with categories. Entity linking resolves mentions to existing graph nodes using candidates and context. Record deduplication identifies records or nodes representing the same entity. Relation extraction identifies relationships expressed between entities; open extraction may additionally require mapping phrases to graph predicates. Together these connect source mentions and records to identities and edges, but they need not execute as separate sequential stages. Integrating external graphs can require both entity alignment and schema alignment. Coverage concerns omitted domain-relevant information. Under open-world semantics, failure to entail an edge does not entail its negation; complete reasoning over supplied axioms does not establish complete real-world coverage.

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

    Quillian's 1967 paper describes encoding dictionary information as a network of elements and associations to investigate memory supporting language behavior. A running program searched this representation to compare word meanings, derive relationships and express its conclusions in English. The motivating problem was organizing and finding conceptual knowledge, rather than retrieving documents for a modern language model.

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

    Brachman and Schmolze report that KL-ONE first appeared as an implementation in 1977. It sought more precise, domain-independent treatment of concepts, roles, inheritance and instantiation than earlier informal semantic networks. The system supported structured descriptions and inference in implemented applications. Its account separates constructing a descriptive concept from asserting that something fitting that description exists: defining a category alone makes no assertion about a particular individual.

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

    In a paper published March 15, 1985, Douglas Lenat, Mayank Prakash, and Mary Shepherd motivated Cyc as a response to brittle AI systems and the labor required to encode expert knowledge. They argued that learning, automatic programming, and language understanding had difficulty scaling without a substantial base of real-world knowledge. Cyc therefore represents a curated commonsense-knowledge line aimed at reusable reasoning, distinct from later web extraction and document retrieval approaches.

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

    Miller, Beckwith, Fellbaum, Gross, and Miller report that Princeton began WordNet in 1985 to support conceptual rather than merely alphabetical access to lexical information. The report, revised in August 1993 and describing WordNet’s 1990 state, organizes words into synonym sets representing lexical concepts and links those sets through typed relations. This made word senses and their semantic connections directly addressable for programs rather than leaving them embedded only in dictionary prose.

22. Resource Description Framework Model and Syntax Specification

    The February 22, 1999 RDF Recommendation addressed exchanging machine-processable descriptions of Web resources between independently developed applications. It supplied a domain-neutral data model and an XML interchange syntax while explicitly distinguishing the model from that syntax. Proposed uses included resource discovery, cataloging and knowledge exchange. Domain meanings were to come from schemas rather than being built into RDF itself.

23. Linked Data — Design Issues

    Berners-Lee's Linked Data note argues that publishing datasets alone does not create an explorable Web of data. Its principles use URI identifiers for things, HTTP lookup to obtain descriptions, and links to other identifiers so people and software can discover related information across publishers. The motivation is connection and reuse beyond the original application, including data otherwise stranded in downloadable archives.

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

    DBpedia converted Wikipedia's existing structured material into RDF to support queries across articles and links to external datasets. Construction mapped relationships from relational tables and parsed article structures such as infoboxes, including identifier and datatype normalization. The paper distinguishes semantically specific properties from ordinary article links, whose existence does not express a specific domain relationship. It also acknowledges contradictory source data, inconsistent categories and extraction problems.

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

    Bollacker, Evans, Paritosh, Sturge, and Taylor presented Freebase at SIGMOD 2008 as a collaboratively created and maintained tuple database for general human knowledge. At publication it contained more than 125 million tuples, 4,000 types, and 7,000 properties and exposed public read/write access through an HTTP graph-query API. Freebase illustrates the shift from specialist knowledge bases toward a shared, application-facing structured-data commons.

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

    Dong and colleagues presented Knowledge Vault at KDD 2014 to expand structured knowledge through automatic extraction from text, tables, page structure, and human annotations, combined with priors from existing repositories. The system used supervised fusion and assigned probabilities to candidate fact correctness. The work marks a consequential construction shift: web-scale coverage required combining noisy extraction channels rather than treating every extracted triple as accepted truth.

27. The Gremlin Graph Traversal Machine and Language

    Marko A. Rodriguez’s 2015 Gremlin paper distinguishes two graph-query perspectives. Traversal moves stateful traversers through vertices and edges according to supplied steps; pattern matching instead returns graph elements that bind variables in a requested subgraph. Gremlin supports both. Its formal graph is a directed, attributed multigraph whose vertices and edges may carry key-value properties, and halted traverser locations form a multiset result. This helps explain why graph querying developed application-oriented traversal semantics alongside declarative pattern matching.

28. The Fellegi-Sunter model — Splink

    Probabilistic record linkage compares how likely an observed agreement or disagreement is among matching records versus nonmatching records. In Fellegi-Sunter notation, m is the observation probability for true matches and u for nonmatches; their ratio is evidence favoring a match. A prior and evidence from multiple fields combine into a match weight. Agreements on common values are weaker evidence than agreements unlikely by coincidence. This explains why entity resolution needs evidence from more than equal display names before it merges records into one graph identity.

29. Leveraging Unlabeled Data to Scale Blocking for Record Linkage

    Blocking selects candidate record pairs before expensive matching. Restating the paper's coverage and precision definitions: let U contain eligible pairs, T⊆U the true matching pairs, and C⊆U the distinct candidates. Candidate recall is |C∩T|/|T|; candidate precision is |C∩T|/|C|. Reduction ratio is 1−|C|/|U| and measures avoided comparisons, not matching accuracy. For deduplication of n records, U has n(n−1)/2 unordered non-self pairs; cross-dataset linkage uses its permitted cross-product. Evaluate blocking against labeled truth that includes matches outside C. Measuring only scored candidates cannot reveal those excluded matches. The paper separates training, development, and test data when learning and evaluating blocking rules.

30. Splink evaluation tutorial: labeled pairs and threshold selection

    Splink evaluates pair predictions against labeled matches and nonmatches, reports false positives and false negatives, and varies the acceptance threshold to examine precision and recall. It requires representative labels for unbiased accuracy analysis. Evaluation decomposition inferred from these definitions: let T be all true matching pairs, C the candidates, and A⊆C the accepted pairs. Decision precision is |A∩T|/|A|. Conditional decision recall is |A∩T|/|C∩T|; end-to-end pair recall is |A∩T|/|T|. Thus end-to-end recall equals candidate recall times conditional decision recall when denominators are nonzero. End-to-end false negatives include both T\C and (T∩C)\A. Report conditional and end-to-end results separately; labels sampled only from high-scoring candidates cannot establish population recall.

31. ER-Evaluation: clustering metrics and evaluation coverage

    Final-cluster pairwise precision measures predicted within-cluster links also present in reference clusters; recall measures reference links recovered by predicted clusters. Form all unordered record pairs within each final cluster, not just accepted scoring edges. If L is this predicted pair set and T the reference pair set, precision=|L∩T|/|L| and recall=|L∩T|/|T|. Exact-cluster precision divides the number of exactly recovered clusters by predicted cluster count; exact-cluster recall divides it by reference cluster count. These distinguish pair recovery from complete entity recovery. Implementation limitation: ER-Evaluation first intersects record IDs and drops missing cluster identifiers. Evaluation inference: verify record coverage explicitly and represent genuinely unmatched records as singleton clusters rather than silently dropping them.

32. Help:Merge — Wikidata

    Wikidata's merge guidance requires checking that items describe the same entity; merge tools perform the selected operation rather than establish identity. Merging transfers statements and references and redirects the obsolete item. Its unmerging procedure restores pre-merge revisions of both items in a specified order. It also warns that bots may have replaced references elsewhere with the merged target, requiring additional reversal. Application inference: repairing a false merge involves both restoring identities and correcting downstream references, not merely deleting an equivalence edge.

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

    Identity resolution remains a limiting dependency even when multiple identification providers are combined.

34. Defining N-ary Relations on the Semantic Web

    The relation-instance pattern introduces a class for a relationship and properties for its participants and attributes. Applied to suppliers, an illustrative instance could be `:r1 a :SupplyRelationship; :supplier :Acme; :customer :Factory; :source :Report; :observedOn "2026-01-10"; :productScope :Bearings`. Another instance can describe a different date, product, or source without mixing its attributes with the first. A bare `:Acme :supplies :Factory` asserts only a binary relationship and provides no distinct relationship instance to qualify. The instance model requires queries through its participant properties; deriving the bare triple requires an explicitly chosen mapping or rule.

35. RDF 1.1 Semantics — W3C

    RDF 1.1 reification uses rdf:Statement, rdf:subject, rdf:predicate, and rdf:object to describe a realization of a triple. This gives provenance or composition metadata a subject to describe. Reifying a triple does not entail the triple, and asserting the triple does not entail its reification. Two reifications with identical subject, predicate, and object need not share metadata. This supports keeping separate source assertions about the same relationship without automatically endorsing the relationship or transferring one assertion's provenance to another.

36. PROV-O: The PROV Ontology — W3C

    PROV-O models provenance through entities, activities, and agents. An activity can use an input entity and generate another; derivation connects an output to the entities from which it was produced, while attribution and association record responsibility. Qualified relations can attach further information about how a derivation occurred. This lets an extracted assertion or summary retain a chain back to source material and the process that produced it. A revision is a new derived entity rather than an unexplained replacement of the original evidence.

37. MinIE: Minimizing Facts in Open Information Extraction

    MinIE separates extracted relations from annotations describing polarity, modality, attribution and quantities. Polarity records whether a statement is negated; modality distinguishes expressed certainty from possibility; attribution identifies the stated supplier of information. Its published Superman example produces the same underlying residence triple from affirmative, negative and uncertain sentences, with different annotations. Dropping those annotations would erase their different meanings. The system also preserves original constituents when minimizing extracted phrases.

38. GraphRAG: The Marriage of Knowledge Graphs and RAG

    The speaker distinguishes structured-data conversion from the harder task of extracting graphs from unstructured text, with mixed records containing long-form text forming a third practical case.

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

    Connect the domain graph of entities to a lexical graph of source documents and chunks, preserving where entities were mentioned.

40. PROV-DM: The PROV Data Model

    PROV represents artifacts as entities, transformations as activities, and responsible people, organizations or software as agents. Usage links an activity to an input entity; generation links an output entity to its producing activity; derivation connects output to source. Attribution associates an entity with an agent, while association assigns responsibility for an activity. Revision is a specialized derivation. Application mapping: identify each source revision, extracted representation and chunk separately; record the extraction or chunking activity, its inputs, outputs and responsible software. Preserve these relationships when generating embeddings or summaries so a derived artifact can be traced back through intermediate representations.

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

    Give the extractor a domain schema instead of asking it to invent unrestricted subject-predicate-object triples.

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

    Add ontology instructions that standardize what values enter the schema, while treating prompt compliance as fallible.

43. W3C PROV-DM: The PROV Data Model

    PROV distinguishes entities, activities and responsible agents, linking records through generation, use and derivation. A transformed document or summary can be represented as a new entity derived from its source, with an identified transformation activity. Revision and invalidation are distinct relations, so a newer or expired record need not silently erase its history. Applied to context assembly, this provides a vocabulary for tracing which source version and processing step supplied an assertion.

44. W3C PROV-DM: Evidence Entities and Derivations

    PROV represents entities, activities and responsible agents, with relations for usage, generation, derivation, revision and attribution. Application design inference: represent each source revision and extracted passage as separately identifiable entities; record which passages an answer-generation activity used and which answer it produced. Store source URI, version or content hash, passage locator, retrieval time and domain-specific effective dates as attributes. Keep publication, retrieval and business-effective times distinct. Preserve conflicting assertions as separate attributed evidence, recording the policy and evidence used to resolve or report the conflict.

45. PROV-DM: The PROV Data Model

    PROV represents a source snapshot and its summary as distinct entities, with a summarization activity that used the snapshot and generated the summary. wasGeneratedBy can record generation time; wasDerivedFrom links the result to its source. Entity attributes can carry application-specific versions, and revision and invalidation relations describe later changes. Applied to retrieval, retain source identity/version, transformation identity, and separate source, retrieval, and summary-generation times. Freshness requires additional application policy: check the authoritative source's current version or validity, inspect invalidation, and enforce a task-appropriate age limit. Generating a summary today does not make its old source facts current.

46. Time in XTDB

    Valid time records when a fact applies in the modeled world; system time records when its version was known to the database. A historical snapshot selects versions satisfying systemFrom≤cutoff<systemTo and validFrom≤targetTime<validTo, treating open ends as unbounded. XTDB exposes these dimensions through FOR SYSTEM_TIME AS OF and FOR VALID_TIME AS OF. A later correction can change past validity without changing the earlier system-time snapshot. Ordinary deletion removes a row from current results while preserving prior versions. Evaluation inference: fix system time at the information cutoff across all inputs and choose valid time for the question being tested; selecting past valid time with current system knowledge can leak later corrections.

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

    A synthesized fact can hide both its original wording and the authority of its actual source, so retain verbatim inputs and explicit links to derived artifacts.

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

    Lineage must survive graph mutation: entity merges retain both source sets, and invalidation records the new evidence responsible for the change.

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

    Representing sources and derived artifacts in a linked graph makes provenance accessible after semantic, lexical, or relational retrieval.

50. GraphRAG output schemas

    GraphRAG persists documents, text units, entities, relationships, communities, and community reports as separate artifacts. Entity descriptions summarize mentions across text units; relationships retain text-unit references; community reports contain generated summaries and full report text. These are derived information surfaces, not merely pointers to original documents. Security design inference: preserve source lineage and applicable access policy through chunking, extraction, merging, and summarization. For an artifact derived jointly from multiple sources, a conservative policy permits access only when the caller may access every contributing source, unless an explicit reviewed policy permits broader release.

51. GraphRAG global search

    Global search uses generated community reports as context, produces intermediate answers in a map stage, and combines selected points into a final answer in a reduce stage. Security inference: filtering original document retrieval alone cannot protect information already incorporated into a report. Authorize reports before map-stage generation, and preserve restrictions through intermediate answers, final answers, conversation history, and caches. After source permissions change, affected derived artifacts must be denied under the updated policy or regenerated from authorized inputs before reuse; removing citations cannot remove information already disclosed.

52. PROV-DM: The PROV Data Model

    PROV represents entities, activities and responsible agents, including people, organizations and software. Derivation connects a resulting entity to a source that affected it; merely participating in the same activity does not establish derivation. Attribution connects an entity to an agent, association records responsibility for an activity, and delegation represents acting on another agent’s behalf while that agent retains responsibility. Identifiers and attributes describe these relationships. This supports lineage records connecting source artifacts, transformations, outputs and responsible actors.

53. SPARQL 1.1 Query Language — W3C

    SPARQL evaluates multisets of variable bindings. Joins combine compatible mappings: multiplicities multiply for each compatible pair and sum when pairs yield the same result. Projection removes variables without removing duplicate rows; DISTINCT deduplicates projected mappings. GROUP BY partitions solutions for aggregation. COUNT(*) counts solutions, COUNT(?x) counts bound non-error values, and COUNT(DISTINCT ?x) counts distinct such values. A fixed sequence such as :item/:price hides intermediate bindings and can return the same endpoint twice through different items. Thus two items priced 5 produce SUM 10. Arbitrary-length * and + instead test connectivity without counting alternative routes; cycles do not generate infinite results. The * operator includes zero steps, while + requires at least one. Surrounding joins and projections can still duplicate endpoints. FILTER keeps only mappings whose expression is true; false and errors remove them. OPTIONAL adds compatible bindings when its pattern matches and otherwise preserves the left mapping with optional variables unbound. Worked case: three named items A/B/C have prices 10/30/absent. In `{?s :name ?n OPTIONAL {?s :price ?p FILTER(?p<20)}}`, results are A/10, B/unbound, C/unbound. Moving FILTER(?p<20) outside OPTIONAL leaves only A/10: B fails the comparison and C produces an unbound-variable error. Unbound is absence of a binding, not zero or an empty string.

54. Operators in detail — Neo4j

    NodeIndexSeek locates nodes through indexed predicates; NodeIndexScan examines indexed values more broadly. Expand(All) traverses matching relationships from each incoming node, while VarLengthExpand(All) traverses variable-length patterns. CartesianProduct combines every left row with every right row, producing m×n rows. A selective starting predicate reduces the rows entering later expansions. Illustrative cost model: with N candidate starts, predicate retention fraction s, and average eligible branching b, a tree-like depth-k expansion may produce approximately N·s·b^k path bindings before later filtering. This is an explanatory estimate, not Neo4j's optimizer formula. High-degree nodes, repeated bindings, joins, and late filtering can make intermediate work much larger than the final answer.

55. Statistics and execution plans — Neo4j

    Neo4j uses database statistics when selecting execution plans, including label counts, relationship counts by type and endpoint labels, and index selectivity. Index statistics are refreshed through sampling mechanisms rather than recalculated for every query. These statistics help estimate the number of qualifying starting nodes and subsequent matches. Consequently, a plan estimate is a data-dependent prediction, not a guarantee that every node has the average degree or every predicate combination behaves independently.

56. Understanding query plans — Neo4j

    Neo4j turns a declarative query into a logical plan and then an executable physical plan. EXPLAIN plans without executing and reports estimated rows; PROFILE executes and reports measurements including rows and database hits. Intermediate cardinality is the number of rows passed between operators, not merely the final result count. Comparing estimated and actual rows helps locate where a plan's assumptions diverge from the data. Inspect row growth and database accesses across the plan before attributing performance to graph size alone.

57. Expand Paths with Config — APOC

    A hop crosses one relationship. APOC's examples constrain traversal by relationship type, direction, and minimum or maximum hop count. Breadth-first search expands one depth level before the next; depth-first search follows a branch to its permitted depth before exploring alternatives. Terminator nodes stop expansion, whereas end nodes constrain returned endpoints while allowing exploration beyond them. Consequently, the same start and endpoint can yield different path sets under different traversal rules. Application inference: include traversal boundaries in the answer contract and do not present depth-limited exploration as unrestricted reachability.

58. Images — Kubernetes

    A container image is an executable software bundle. Image tags can be reassigned to different images, whereas digests are immutable hashes identifying image content. Kubernetes accepts image references containing a digest; when both tag and digest are supplied, the digest determines what is pulled. Application inference: connect an artifact-specific dependency inventory to a deployment through an identified image digest rather than assuming a mutable tag always denotes the same artifact.

59. Vulnerability Exploitability eXchange — CycloneDX

    Vulnerability Exploitability eXchange, or VEX, communicates whether a component vulnerability is exploitable in the particular product context. CycloneDX distinguishes this contextual assessment from a general vulnerability disclosure. Application inference: a dependency path can identify a component requiring investigation without establishing that its vulnerability is exploitable in the deployment.

60. Deployment API Reference — Kubernetes

    DeploymentStatus represents the most recently observed deployment state. observedGeneration identifies the generation seen by the controller; updatedReplicas counts non-terminating Pods with the desired template; readyReplicas and availableReplicas describe different readiness conditions. Deployment conditions include status, reason, lastUpdateTime, and lastTransitionTime. Application inference: retain the observed generation, relevant status, and observation timing alongside a graph assertion about deployment state instead of treating the desired template as proof of completed deployment.

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

    For events A1 through Ak, the probability that all hold is P(A1) multiplied by each successive conditional probability P(Ai|A1,…,A(i−1)), when the conditioning events have positive probability. Applied to graph reasoning, define Ai as the correctness of a premise, identity decision, or reasoning step. The chain rule requires dependency information; isolated edge scores do not supply it. Furthermore, the probability that every premise in one sufficient proof is correct is not generally the probability of the conclusion, which may have other proofs.

62. Introduction to Probability — Independence

    Independent events satisfy P(A∩B)=P(A)P(B); mutual independence extends multiplication to all events in a chain. Pairwise independence alone is insufficient for that extension. As an illustrative calculation, five mutually independent premises with probability 0.9 each are jointly correct with probability 0.9^5≈0.59049. This calculation is unjustified if the premises share errors or dependencies. Graph interpretation: facts copied from one source or steps depending on one mistaken entity merge cannot simply be treated as independent confirmations.

63. Maintaining Views Incrementally

    For nonrecursive views, the counting algorithm tracks alternative derivations of each tuple, not source documents. Under set semantics, a tuple remains while its derivation count is positive: c'=c+addedDerivations−removedDerivations. Removing one proof must preserve results with another proof. For recursive views, DRed overdeletes potentially affected tuples, rederives those still supported, and propagates insertions. Cycles make unrestricted derivation counting problematic. Application inference: keep source-contribution accounting distinct from derivation accounting. If explicit assertions are a set, a contribution count changing from zero to positive inserts an explicit assertion; changing from positive to zero removes it. Other contribution-count changes leave that explicit set unchanged. An assertion losing explicit support may nevertheless remain logically derivable.

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

    Inspecting the returned graph context can expose retrieval and extraction problems that developers can correct.

65. Practical GraphRAG: Making LLMs Smarter with Knowledge Graphs

    Expose the source documents, retrieved chunks, and graph entities supplied to the model so users can inspect the answer's retrieval basis.

66. The Knowledge Graph Mullet: Trimming GraphRAG Complexity

    Use vector matches as starting nodes, then expand through domain relationships to retrieve additional documents.

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

    The described architecture uses vector search to select seed nodes, traverses their graph neighbors, and ranks the expanded candidates for context.

68. Practical GraphRAG: Making LLMs Smarter with Knowledge Graphs

    Vector similarity can find topical matches without retrieving all information needed to answer the question.

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

    GraphRAG extracts entities and relationships from source text, builds a graph, partitions it into hierarchical communities, and generates community summaries. For global sensemaking questions, the query stage forms partial answers from community summaries and combines them through a map-reduce process. The paper evaluates comprehensiveness and diversity on corpus-wide questions, not just retrieval of one nearby passage. Its mechanism explains why a graph index can provide a different view of a corpus from a small nearest-neighbor chunk set.

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

    Separate offline data processing and index construction from online retrieval and answer generation.

71. The Life of an Entity — Backstage

    Backstage ingests authoritative source records, processes entities and relationships, and assembles the published catalog. Processing errors prevent replacement of the previously error-free entity. Its internal graph of which records produced other records is distinct from domain relationships. Provider deletion removes dependent entities only when no other parent keeps them alive. Explicitly deleting an entity still emitted by an active parent causes it to reappear on subsequent processing. Missing or unreadable source files produce errors rather than automatically proving removal.

72. Deleting Data from the Graph — Zep

    Zep associates source episodes with derived graph nodes and edges. Deleting an episode preserves nodes and edges associated with other episodes, with an additional exception preserving the user entity. However, deletion does not regenerate shared-node names or summaries, so information from the deleted episode can remain there. Deleting an episode that invalidated a fact also leaves that fact invalidated. Thus source-association deletion, summary reconstruction and reversal of earlier invalidation are separate maintenance effects.

73. PostgreSQL INSERT: conflict handling and returned insertions

    PostgreSQL supports uniqueness-based ON CONFLICT DO NOTHING; RETURNING reports only successfully inserted or updated rows. Application contract inferred from these primitives: store contributions separately from canonical assertions, with a non-null unique key (source_id, source_version, assertion_id). Fix assertion normalization and the extraction result for each immutable version. Insert contributions with DO NOTHING RETURNING assertion_id; increase support only for returned rows, grouped by assertion. Replaying an identical version returns no new contributions, so support is unchanged. A different source_id inserts another contribution even for the same assertion. Define source_support(a) as the number of active contribution rows for a. This counts source-version contributions, not independent evidence or logical proofs.

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

    Materialization precomputes consequences of explicit facts and a Datalog program, allowing subsequent queries to operate directly on the resulting facts. For positive function-free Datalog over a finite domain, repeated rule application can be described as I0=E and I(n+1)=I(n)∪TΠ(I(n)), stopping when no new facts appear. Insertions can continue consequence generation from the existing materialization; deletions must distinguish unsupported results from results with remaining derivations. Equality creates additional maintenance work because equivalent terms may have been represented by a shared representative.

75. Document-level access control — Azure AI Search

    Azure AI Search documents two relevant mechanisms: application-supplied security filters and supported native permission-metadata enforcement. Query-time enforcement evaluates caller identity against permissions already stored in the index. Source permission changes become effective only after the corresponding metadata is synchronized through the source-specific mechanism, such as an indexer run or push update. Therefore permission synchronization latency is part of retrieval security, not merely indexing freshness. Application inference: enforce current policy before admitting retrieved content to generation, and invalidate affected cached or derived results when access is revoked.

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

    For a query, let R be retrieved items and G the relevant items in the evaluation collection. Precision=|R∩G|/|R|=TP/(TP+FP); recall=|R∩G|/|G|=TP/(TP+FN). Recall's denominator includes relevant items that were not retrieved. These are generic set-retrieval definitions, independent of RAGAS. Applying them to chunks or graph evidence requires declaring that counting unit and its relevance judgments; do not mix chunk numerators with document denominators. For a fixed top-k result set, use that set as R. Balanced F1=2PR/(P+R) combines the two when defined.

77. Ragas Faithfulness

    Ragas Faithfulness decomposes the generated response into claims, judges whether each follows from retrieved context, and divides supported response claims by all response claims. Unlike Context Recall, its denominator comes from the response rather than the reference answer. Interpretation: a response can faithfully repeat false source content, so high faithfulness does not independently establish real-world factual correctness. Conversely, an externally correct statement absent from context may receive no faithfulness credit. The metric measures contextual support through a judge, not source authentication.

78. The Gene Ontology Knowledgebase in 2026

    Gene Ontology associates gene products, such as proteins, with defined functional concepts through evidence-backed annotations. Its maintainers review annotations when ontology definitions, experimental evidence or annotation guidelines change. Retiring several overly broad binding terms required manual review of more than 2,000 annotations because replacement concepts distinguished different biological roles. The report also describes automated checks that external mappings resolve to valid identifiers. It warns that ontology and annotation changes can change downstream analyses and therefore requires identifying the release used.

79. OBO Foundry Principle 19: Stability of Term Meaning

    OBO Foundry requires a new term and identifier when a definition change would substantially change what the term denotes. Clarifications that preserve meaning are permitted. Deprecation requires marking the term obsolete, removing its logical axioms, and removing or replacing its use elsewhere in the ontology. Exact replacements are distinguished from alternatives requiring consideration. Developers should announce obsoletions and provide migration guidance. The documented dashboard checks detect obsolete terms that still participate in logical axioms.

80. The Knowledge Graph Mullet: Trimming GraphRAG Complexity

    Use canonical entities and explicit relationship semantics rather than undifferentiated links between strings.

81. Why Agentic Systems Need Ontologies

    The speaker presents expert-led modeling and observation-led enrichment as two ways to construct an ontology.