Knowledge Graph Glossary: 60+ Terms Defined

Q: What is the difference between a knowledge graph and an ontology?

An ontology is the schema: the classes, properties and rules that say what kinds of thing exist and how they may relate. A knowledge graph is the data: the individual entities and the statements about them, usually organized by an ontology. An ontology with no instance data is a vocabulary; a graph of instance data with no ontology is a pile of edges nobody can interpret consistently.

This glossary defines the vocabulary used across Knowledge Graph Navigator, from the identifiers that appear in every Wikidata query to the schema.org properties that appear in every structured data block. Terms are grouped alphabetically, and each one links to the page that covers it in depth where such a page exists. The same word sometimes means different things to a data engineer and to an SEO, and where that happens the entry says so.

A

Axiom

A logical statement in an ontology that constrains how classes and properties may be used, such as “nothing is both a Person and an Organization” or “a birthDate has at most one value”. Axioms are what separate an ontology from a list of terms, because they let a reasoner derive new facts and detect contradictions. They describe what is logically true rather than rejecting bad data, which is validation and belongs to SHACL.

B

Blank node

A node in an RDF graph that has no global identifier and exists only within the document or store that contains it, written _:b1 in Turtle. Blank nodes are correct for things with no identity of their own, such as a postal address nested inside a Person, and wrong for anything another dataset might want to reference. A JSON-LD object with no @id becomes a blank node, which is the usual reason two pages describing the same organization fail to merge into one entity.

C

@context

The JSON-LD key that maps the short property names in a document to full IRIs, so that "name" is read as https://schema.org/name. Setting "@context": "https://schema.org" is what turns an ordinary JSON object into RDF. Without it a parser has plain JSON with no defined meaning. See JSON-LD.

Class

A category of entity in a schema or ontology, such as Person, Organization or City, to which individual entities are assigned with rdf:type. A class is a set defined by membership rather than a template with fixed fields, so one entity can belong to several classes at once. Classes are arranged in hierarchies with rdfs:subClassOf, which is how a schema.org LocalBusiness inherits every property of Organization.

Content negotiation

The HTTP mechanism by which one URI serves different formats depending on the client’s Accept header, so that a browser asking for text/html gets a readable page and a program asking for text/turtle gets RDF. It is how a single identifier such as http://www.wikidata.org/entity/Q243 can be both a web page and a machine-readable description. Content negotiation is the practical machinery behind dereferenceable identifiers in linked data.

CONSTRUCT query

One of the four SPARQL query forms, which returns an RDF graph built from a template rather than a table of rows. It reshapes data from one vocabulary into another, extracts a subgraph for export, or generates triples to load elsewhere. SELECT returns bindings, ASK returns true or false, DESCRIBE returns whatever the endpoint considers a useful description, and CONSTRUCT returns triples. See SPARQL.

CURIE

A compact URI: a short form written as a prefix, a colon and a local name, such as wdt:P31 or schema:name, that expands to a full IRI once the prefix is declared. Turtle, SPARQL, RDFa and JSON-LD all use the pattern, though the declaration syntax differs in each. A CURIE is not itself an identifier, and it means nothing without the prefix binding that resolves it.

Cypher

The query language for labeled property graphs, originally created for Neo4j, opened as openCypher in 2015, and the basis of the ISO GQL standard published in 2024. Its syntax draws paths in ASCII art, so (a)-[:KNOWS]->(b) matches a KNOWS edge between two nodes. Cypher reads and writes edge properties directly, which SPARQL cannot do without reification. See property graph vs RDF.

D

Datatype

An IRI attached to an RDF literal that tells a consumer how to interpret its lexical form, written with a double caret: "330"^^xsd:decimal, "1889-03-31"^^xsd:date. Without a datatype, a number is a string and will sort alphabetically rather than numerically, so a SPARQL filter such as ?height > 300 will not behave as expected. A literal with no datatype and no language tag is treated as xsd:string.

DBpedia

A knowledge graph produced by extracting structured data out of Wikipedia and republishing it as RDF with dereferenceable URIs and a public SPARQL endpoint, started in 2007 and long the hub of the linked open data cloud. Nobody edits DBpedia directly: its content changes when Wikipedia changes, which explains both its breadth and its inconsistencies. It is not the same project as Wikidata, which contributors edit directly. See DBpedia.

Dereferencing

Looking up an HTTP URI to retrieve a description of the thing it identifies. It is the second of the four linked data principles and the reason identifiers are minted as http:// URIs rather than opaque codes: the identifier doubles as the address where its own data lives. A URI that returns nothing when fetched is still a valid identifier, but it is not linked data.

Disambiguation

The step in entity linking that chooses which candidate entity a mention refers to when several share a name. “Paris” may be the French capital, a city in Texas, or a person, and the system decides using the surrounding words, the other entities in the document, and how often the surface form usually refers to each candidate. Disambiguation is a separate problem from recognizing that a span is a name at all, which is NER.

Domain and range

Two RDFS declarations that state which class the subject of a property belongs to (rdfs:domain) and which class or datatype its object must be (rdfs:range). Declaring teaches with domain Professor and range Course tells a reasoner that anything appearing as the subject of teaches is a Professor, even if no triple says so. In RDFS and OWL, these drive inference rather than rejection, so a value of the wrong type produces a strange conclusion, not an error. See ontologies.

E

Edge

A directed, typed connection between two nodes in a graph. In RDF, an edge is a triple; its label is the predicate IRI, and it can carry no data of its own; in a labeled property graph, an edge is a record with a type, a direction, and its own property map, which is where a weight or a timestamp goes. This asymmetry is the single most consequential difference between the two models.

Embedding

A fixed-length vector of numbers that represents an object (a word, a sentence, a document chunk, or a graph node) so that similar objects land near each other in the vector space. Text embeddings capture what a passage means; knowledge graph embeddings capture where a node sits in a graph. They answer “what resembles this” and cannot answer “how exactly are these two things connected”, which is what traversal is for.

Entity

A uniquely identifiable thing or concept, whether physical (the Eiffel Tower), organizational (the University of Florida) or abstract (the element mercury), that exists independently of the words used to name it. In knowledge graphs and search, an entity is the thing itself carrying a stable identifier, not any of the strings that refer to it. An entity is not a keyword, and one entity typically has many names across languages and contexts. See what is an entity.

Entity linking

The task of resolving a mention in text to a specific identifier in a knowledge base, for example, mapping “Curie” in a biography to Wikidata Q7186. It includes candidate generation, disambiguation, and the decision to return NIL when no candidate is right. Entity linking follows named entity recognition: NER answers whether a span is a person, and linking answers which person. See entity extraction, NER and entity linking.

Entity SEO

The practice of making the things a site is about identifiable to search engines as distinct entities with stable identifiers, rather than as collections of keywords. The work is ordinary publishing (consistent naming, an entity home page, accurate markup, sameAs links to reference identifiers) applied with identity in mind. It does not create an entry in Google’s graph on demand, and no markup obliges a search engine to recognize an entity. See entity SEO.

F

Federated query

A SPARQL query that sends part of its pattern to a remote endpoint with the SERVICE keyword and joins the results locally, so a private graph can be queried against Wikidata in one statement. It is standardized as SPARQL 1.1 Federated Query and has no equivalent in the property graph world. In practice, federation is limited by remote endpoint timeouts and by how selective the sub-pattern is. See SPARQL.

G

Google Knowledge Graph

Google’s internal store of entities and their relationships, announced in May 2012 under the phrase “things, not strings” and seeded from Freebase. It lets Search treat a query as about an entity rather than a string, and it supplies the facts behind knowledge panels. It is not a public dataset: the only documented access is the Knowledge Graph Search API, which exposes a limited entity lookup. See Google Knowledge Graph.

GQL

The ISO standard graph query language for property graphs, published in April 2024 as ISO/IEC 39075:2024 and drawn closely from Cypher. Its arrival gave the property graph model a formal standard for the first time; vendor adoption is ongoing, and most production code is still written in Cypher. GQL is a separate language from SQL/PGQ, which adds property graph pattern matching inside SQL:2023.

Graph database

A storage and query system built around nodes and edges, including labeled property graph products such as Neo4j and Memgraph and RDF triple stores such as GraphDB and Stardog. A graph database is the container and the engine, not the content: it can hold data nobody would call a knowledge graph, and a knowledge graph can equally live in Turtle files or a relational schema. See graph databases and knowledge graph vs graph database.

GraphRAG

Retrieval-augmented generation in which some or all of the retrieval runs over a knowledge graph instead of a flat index of text chunks, so the system identifies entities in the question, traverses their relationships, and hands a connected subgraph to the language model. It covers a family of designs rather than one method, and it earns its cost on multi-hop and aggregation questions that vector similarity cannot assemble. On single-passage questions, plain vector retrieval usually wins. See GraphRAG.

I

@id

The JSON-LD key that supplies the IRI identifying the node being described, becoming the subject of every triple in that object. Omitting it produces a blank node, so two pages describing the same organization create two anonymous subjects a parser has no reason to merge. Giving every mention of an entity the same @id is what collapses them into one node. See JSON-LD.

Inference

The derivation of triples that were never asserted, using the rules an ontology declares. If Professor is a subclass of Person and Marie Curie is typed as a Professor, an RDFS reasoner concludes she is a Person, and a SPARQL query for all Persons returns her. Inference adds facts rather than rejecting data, so it does not substitute for validation. See ontologies and OWL.

IRI

An Internationalized Resource Identifier: a URI extended to allow characters beyond ASCII. RDF is defined over IRIs, so subjects and predicates are IRIs, and objects are IRIs or literals. In everyday use, “URI” and “IRI” are interchangeable in this field, and the specifications say IRI where older documents say URI. See RDF.

J

JSON-LD

A W3C Recommendation that expresses linked data as ordinary JSON, so one document is both a normal object a JavaScript parser can read, and a set of RDF triples a graph store can load. Version 1.0 became a Recommendation in 2014 and version 1.1 in 2020. On the web, it is best known from <script type="application/ld+json"> blocks, the format Google recommends for schema.org markup. See JSON-LD.

JSONL

JSON Lines, a text format holding one complete JSON value per line with no enclosing array and no commas between records. That single rule makes it streamable, appendable, and splittable, which is why it is the usual shape for training data, bulk loads, and graph dumps. JSONL is not JSON-LD: it is a container format with no notion of context, identifiers or triples. See JSONL.

K

Knowledge graph

A network of real-world entities and the typed relationships between them, stored so that both software and people can query it, usually with a schema or ontology giving the types their meaning. The term covers Google’s internal graph, public datasets such as Wikidata, and private enterprise graphs alike. It names the content, not the technology: a knowledge graph is not the same thing as a graph database. See what is a knowledge graph.

Knowledge graph embedding

A learned representation in which every entity and relation in a graph is assigned a vector, chosen so that a scoring function separates true triples from false ones. Trained models are used for link prediction (suggesting edges the graph is missing), entity classification, and feeding graph structure into other machine learning systems. Most classic models are transductive, meaning a node absent at training time has no vector. See knowledge graph embeddings.

Knowledge panel

The information box Google Search shows when it decides a query refers to a specific entity it holds, summarizing that entity with a name, a type label, a description, an image, and a set of facts. Google generates panels automatically, with no application process and no paid placement. A knowledge panel is a display surface, not the graph itself, and its absence does not mean an entity is missing from the graph. See Google knowledge panel.

L

Labeled property graph (LPG)

A graph data model in which nodes carry zero or more labels and a map of key-value properties, and directed edges carry exactly one type plus their own properties. It is the model behind Neo4j, Memgraph, and TigerGraph, queried with Cypher or GQL. Node identity is local to one database, so merging two property graphs is an integration project rather than a set union. See property graph vs RDF.

Language tag

A short code appended to an RDF literal to record the natural language of its text, written "Eiffel Tower"@en and "Tour Eiffel"@fr. The two are separate triples that coexist in one graph without conflict, which is how multilingual labels work in Wikidata. A literal can carry a language tag or a datatype, not both, and retrofitting tags onto a large untagged graph is tedious.

Linked data

A method of publishing structured data so that each thing has an HTTP URI, each URI returns useful data when looked up, and that data links to URIs on other sites. The four principles come from a 2006 design note by Tim Berners-Lee. When the data is also released under an open license, it is called linked open data; Wikidata and DBpedia are the best-known examples. See linked data.

Literal

A concrete value in an RDF graph such as a string, number, date or boolean, optionally carrying a datatype IRI or a language tag. Literals can appear only in the object position, because a literal is a value rather than a thing that can have properties of its own. To say something about a value, promote it to a node. See triples.

M

MID

A machine ID: the opaque identifier Google uses for entities in its knowledge graph, inherited from Freebase and usually of the form /m/0dl567, with newer entities appearing under /g/ instead. Nothing in a MID encodes the entity’s type or name, and it stays stable across name changes. A MID cannot be requested, minted or asserted by a publisher; it surfaces through the Knowledge Graph Search API and a few other Google products. See Google Knowledge Graph.

Microdata

An HTML syntax for structured data using five attributes (itemscope, itemtype, itemprop, itemid, itemref) that annotate the elements already displaying a page’s content. The WHATWG HTML living standard defines it, and Google fully parses it, though JSON-LD is now the recommended format. Microdata is a syntax, not a vocabulary: the vocabulary it usually carries is schema.org. See Microdata.

N

Named entity recognition (NER)

The task of finding the spans of text that mention an entity and assigning each a coarse type such as Person, Organization, Location, or Date. It is a sequence labeling problem, handled today by fine-tuned transformer models and, increasingly, by prompted language models. NER stops at the type: it does not say which person, which is entity linking. See entity extraction, NER and entity linking.

Named graph

An IRI-identified subset of triples inside an RDF dataset, used to keep provenance (these triples came from Wikidata, those from an internal system), apply access control, or delete a source as a unit. SPARQL restricts matching to one with the GRAPH keyword. TriG and N-Quads are the serializations that can carry the graph name; Turtle and N-Triples cannot.

Namespace

The IRI prefix shared by all terms in a vocabulary, such as http://www.w3.org/2000/01/rdf-schema# for RDFS or https://schema.org/ for schema.org. Grouping terms under one namespace is what makes schema:name and foaf:name unambiguously different properties despite the identical local name. A namespace is a naming convention, not a container: nothing enforces that the IRIs under it resolve or that they belong together.

NIL

The value an entity linker returns when a mention has no matching entity in the target knowledge base. Handling NIL correctly is one of the harder parts of linking, because a system that always forces a match will confidently attach a small local business to a famous namesake. NIL mentions are often clustered across documents so the same unknown entity can later be added to the graph as a new node.

Node

A vertex in a graph: an entity, a class, or, in RDF, anything appearing in the subject or object position of a triple. RDF has no separate node record, so an entity is defined entirely by the triples that mention it; a property graph node is a real record with labels and a property map. Literals are values rather than nodes in the sense that matters, because nothing can be said about them.

N-Triples

An RDF serialization that writes one complete triple per line with full IRIs in angle brackets and no prefixes. The verbosity is deliberate: because every line is independent, N-Triples files can be split, streamed and appended, which makes the format the usual choice for large dumps and bulk loads. N-Quads is the same format with a fourth position for a named graph.

O

Object

The third position in an RDF triple: the value or target of the statement. It may be an IRI (linking to another node), a blank node, or a literal. The object is the only position in which a literal may appear, which is why describing a value in more detail requires promoting it to a node. See triples.

Ontology

A formal, machine-readable definition of the types of things in a domain, the properties they can have, and the rules governing how they relate. In a knowledge graph, the ontology is the schema layer and the entities are the data layer. An ontology is not a database schema: a relational schema constrains what you can store, while an ontology describes what is true and lets a reasoner add facts. See ontologies.

Open Graph protocol

A specification, introduced by Facebook in 2010 and documented at ogp.me, for describing a page as a structured object with <meta property="og:…"> tags so link previews render a title, description, and image. It is defined as an RDFa vocabulary, which makes every og:title tag a real RDF predicate and Open Graph arguably the most widely deployed RDF on the web. It is a preview format, not a search ranking signal. See Open Graph protocol.

Open-world assumption

The principle, built into RDF and OWL, that the absence of a statement means unknown rather than false. If no triple says Marie Curie has a sibling, an OWL reasoner does not conclude she has none. This is the opposite of the closed-world assumption in relational databases, and it is the reason validation needs SHACL rather than OWL axioms.

OWL

The Web Ontology Language is the W3C standard for writing ontologies with enough logic that software can derive new facts and detect contradictions. It adds disjointness, cardinality restrictions, property characteristics such as transitivity and inverses, and class definitions built from restrictions, all beyond what RDFS offers. OWL 2 became a Recommendation in 2009, with a second edition in 2012, and includes EL, QL, and RL profiles that trade expressivity for predictable reasoning cost. See OWL.

P

P-ID

The identifier of a property in Wikidata, written with a leading P: P31 is “instance of”, P279 is “subclass of”, P19 is “place of birth”. Each property has a fixed datatype that constrains its values, which keeps the data machine-readable. P-IDs are the predicate half of Wikidata’s vocabulary, with Q-IDs supplying the subjects and objects.

Predicate

The second position in an RDF triple: the relationship or property being asserted. It must be an IRI drawn from a vocabulary, such as rdf:type, rdfs:label or schema:location. Because predicates are IRIs, they can themselves be the subject of triples that describe them, which is how a vocabulary defines its own terms. See triples.

Prefix

A short alias bound to a namespace IRI so that terms can be written as CURIEs, declared with @prefix schema: <https://schema.org/> . in Turtle and PREFIX in SPARQL. Prefix names are local to the document that declares them, so wd: means only what the file says it means. Some SPARQL endpoints, including the Wikidata Query Service, predeclare the common ones.

Property

A named relationship or attribute that entities can have. RDFS and OWL divide them into object properties, whose values are other entities, and datatype properties, whose values are literals; schema.org keeps one flat list with expected types. In a labeled property graph, “property” means a key-value pair stored on a node or edge, which is a narrower and different use of the word.

Provenance

The record of where a statement came from: the source document, the extraction model, a confidence score, a timestamp, or a citation. It is what allows extracted triples, which are hypotheses, to be distinguished from curated facts and corrected later. RDF handles it with named graphs, reification, or RDF-star; Wikidata handles it with references attached to each statement.

Q

Q-ID

The identifier of an item in Wikidata, written with a leading Q: Q937 is Albert Einstein, Q7186 is Marie Curie, Q243 is the Eiffel Tower. Because Wikidata is public, multilingual, and heavily cross-referenced, Q-IDs have become the common neutral identifier for tying a private graph or a sameAs link to a shared reference. Q-IDs and Google MIDs are separate schemes with no complete crosswalk.

Quad

A triple plus a fourth element naming the graph it belongs to, which is how an RDF dataset keeps track of which source asserted what. N-Quads and TriG are the serializations that carry the fourth position. A store supporting quads is often called a quad store, though “triple store” is used loosely for both.

Qualifier

In Wikidata, an additional property-value pair attached to a statement to scope or refine it, such as a start date on a position held, or a point in time on a population figure. Qualifiers exist because a plain triple has nowhere to put context. The same problem is solved in general RDF by reification or RDF-star.

R

RDF

The Resource Description Framework, the W3C’s data model for describing things and their relationships as a graph of subject-predicate-object statements. It defines what a statement is, what may appear in each position, and how statements combine into graphs and datasets. RDF is a model, not a file format, and it is not synonymous with RDF/XML, its original and now least-used serialization. See RDF.

RDFa

A W3C Recommendation that embeds RDF in HTML, XHTML, and XML using attributes such as vocab, typeof, property and resource, so the visible text and the machine-readable statement are the same string. RDFa 1.1 and the simplified RDFa Lite profile both reached second-edition Recommendation status in 2015. Its widest deployment is indirect: the Open Graph protocol is defined as an RDFa vocabulary. See RDFa.

RDFS

RDF Schema, the W3C vocabulary that adds classes, subclasses, properties, subproperties, domain and range to RDF. It is enough to build a usable vocabulary and to support simple inference such as subclass inheritance, and it stops well short of the logic in OWL. Many production graphs use RDFS plus a few OWL constructs and leave data quality to SHACL. See ontologies.

RDF-star

An extension that allows a triple to appear as the subject or object of another triple, written << s p o >> q v ., so a statement can be annotated with a date, a source, or a confidence without reification. It began as a community proposal and is being folded into the RDF 1.2 and SPARQL 1.2 work at the W3C, with several stores already supporting it. RDF-star is the closest RDF equivalent to edge properties in a labeled property graph. See triples.

Reasoner

Software that applies the rules in an ontology to a data graph and materializes or answers with the entailed triples. RDFS reasoning propagates subclass, subproperty, domain, and range; OWL reasoning adds disjointness checking, inverse and transitive properties, and consistency detection. Reasoning costs scale with graph size, which is why OWL 2 defines profiles with predictable performance. See OWL.

Reification

The pattern of representing a statement as a node so that other statements can be made about it, for example, creating an award event node to hold the year an award was received. It is the pre-RDF-star way to attach context to a triple, and Wikidata’s statement and qualifier structure implements it at scale. The cost is that every annotated fact becomes several triples and every query has to route through the intermediate node.

Rich result

A search result rendered with extra visual features (review stars, recipe times, FAQ accordions, breadcrumbs) that Google generates when a page carries structured data matching one of its documented feature requirements. Only a subset of schema.org drives rich results, and valid markup makes a page eligible rather than guaranteeing the treatment. Rich results and knowledge panels are different things: one decorates a page listing, the other describes an entity. See structured data.

S

Salience

A score between 0 and 1 that Google’s Cloud Natural Language API returns for each entity it finds in a text, indicating how central that entity is to the passage. SEOs use it to check whether the entity a page is meant to be about is in fact the most prominent one the API sees. It is a property of one API’s output, not a ranking factor Google has described.

sameAs

A schema.org property whose value is the URL of a reference page that unambiguously identifies the thing being described, typically a Wikipedia article, a Wikidata item, or an official profile. It is an identity claim, not a relatedness claim: pointing sameAs at a founder’s page from a company block asserts that the company and the person are the same thing. Misused, it actively confuses the entity it was meant to clarify. See sameAs schema.

Schema.org

A shared vocabulary of types and properties for describing things on the web, launched in June 2011 by Bing, Google and Yahoo, joined shortly after by Yandex, and now developed through a W3C community group. It supplies the words (Person, Product, author, startDate) but not the syntax, which is why the same vocabulary appears inside JSON-LD, Microdata and RDFa. It is a lightweight ontology with a type hierarchy and expected types, but few formal axioms. See schema.org.

Semantic SEO

The practice of planning and writing content around topics, entities and the relationships between them rather than around keyword strings, on the reasoning that a search engine interprets what a query means before it retrieves anything. It follows from documented changes in query handling: spelling correction, synonym expansion, intent classification, and passage-level relevance. It does not mean adding more schema markup, which is a separate activity. See semantic SEO.

Semantic web

An extension of the web, proposed by Tim Berners-Lee and standardized by the W3C, in which data is published in machine-readable form so software can interpret meaning rather than only render documents. Its stack is RDF, RDFS, OWL, SPARQL, SHACL and JSON-LD. “Semantic web” names the standards and the vision; “knowledge graph” names the data artifact, and most knowledge graphs use these standards or descend from them. See the semantic web.

Serialization

A concrete file syntax for writing an abstract data model down. RDF has several (Turtle, N-Triples, N-Quads, TriG, JSON-LD, RDF/XML, RDFa), and a conformant parser produces the identical graph from any of them. Choosing a serialization is a question of tooling and readability, never of what the data means. See RDF.

SHACL

The Shapes Constraint Language, a W3C Recommendation since 2017, is for validating RDF against shapes that say what a conforming node must look like: which properties it must have, how many values each may take, and of what type. A processor checks a data graph against a shapes graph and returns a machine-readable report of every violation. SHACL rejects bad data; OWL infers new facts. The two are complementary, not alternatives. See SHACL.

SKOS

The Simple Knowledge Organization System, a W3C Recommendation from 2009 and an RDF vocabulary for publishing taxonomies, thesauri, and controlled vocabularies. Its core is skos:Concept, with skos:broader and skos:narrower for hierarchy, skos:related for associations, and prefLabel, altLabel and hiddenLabel for names. skos:broader deliberately carries no logical entailment, unlike rdfs:subClassOf, which is what makes SKOS right for navigational hierarchies. See ontologies.

SPARQL

The W3C standard query language and protocol for RDF. A query states a pattern of triples with variables in some positions, and the engine returns every set of bindings that matches. SPARQL 1.1 became a Recommendation in 2013, adding aggregates, subqueries, property paths, federation and a separate update language. See SPARQL.

SPARQL endpoint

An HTTP service that accepts SPARQL queries and returns results as JSON, XML, CSV or TSV. Public endpoints such as the Wikidata Query Service and DBpedia’s make large graphs queryable without downloading them, subject to timeouts and rate limits. An endpoint URL is not a web page: fetching it in a browser without a query usually returns an error or a query form. See Wikidata Query Service.

Structured data

In the web sense, machine-readable markup embedded in a page stating what its content means: which strings are names, which are prices, which are dates, and which real-world thing the page is about. It is the on-page layer of a knowledge graph, and almost all of it uses schema.org. Structured data restates facts already visible on the page; markup that describes content not present is a policy violation, not a shortcut. See structured data.

Subject

The first position in an RDF triple: the thing the statement is about. It must be an IRI or a blank node, never a literal, because a value cannot have properties of its own. In JSON-LD, the subject comes from @id, and its absence is what produces an unmergeable blank node. See triples.

T

Taxonomy

A set of terms arranged in a hierarchy using a single relationship, usually broader and narrower. A taxonomy states that Cardiology is narrower than Medicine and nothing more; an ontology additionally states that a Cardiologist is a Physician, that a Physician treats Patients, and that nothing is both a Physician and a Hospital. Every taxonomy can be expressed inside an ontology. See knowledge graph vs ontology.

Thesaurus

A controlled vocabulary that adds associative and synonym relationships to a taxonomy’s hierarchy, recording that “heart disease” and “cardiac disease” label the same concept and that Cardiology is related to Cardiac Surgery. It sits between a taxonomy and an ontology in expressive power and is the artifact SKOS was designed to publish. It describes terms and concepts rather than making logical claims about the world.

Topical authority

A practitioner model describing the observation that a site covering a subject thoroughly and coherently tends to rank more easily across that subject than one covering it in fragments. Google does not publish a metric for it, and no search engine has described a per-topic authority score. The work it implies (covering the entities a topic contains, linking pages by real relationships) is defensible whether or not the model matches any internal mechanism. See topical authority.

Triple

A single RDF statement made of a subject, a predicate and an object, asserting that the subject has the named relationship to the object. “The Eiffel Tower is located in Paris” is one triple, and a set of triples is a graph. A triple is not a row with three columns: rows are independent, while triples share nodes through reused IRIs, and that sharing is what makes the graph. See triples: subject, predicate, object.

Triple store

A database built to hold RDF triples (or quads, when named graphs are supported) and answer SPARQL queries over them, indexing the subject, predicate, and object positions in several orders so any pattern can be matched quickly. Examples include Apache Jena, RDF4J, GraphDB, Stardog, Blazegraph, Virtuoso, and Oxigraph. A triple store is a graph database; the choice between it and a property graph store is a choice of data model. See graph databases.

Turtle

The Terse RDF Triple Language, the most readable RDF serialization, which declares prefixes and then lists triples ending in periods, with a semicolon to repeat a subject and a comma to repeat a subject and predicate. The keyword a is shorthand for rdf:type. Turtle is the usual format for hand-written examples, ontologies and SHACL shapes. See RDF.

U

URI

A Uniform Resource Identifier: the global name given to a thing so that two systems referring to it are demonstrably referring to the same thing. In linked data, URIs use the http:// scheme, so they double as addresses that can be dereferenced. RDF is formally defined over IRIs, the internationalized form, and the two words are used interchangeably in practice. See linked data.

V

Vector database

A store that holds embeddings and answers nearest-neighbor queries, indexing vectors with structures such as HNSW or IVF so it can return the closest matches to a query vector quickly. Relationships between items are implicit: two records are related to the degree their vectors are close, and nothing records why. It answers similarity questions; a knowledge graph answers connection questions. See knowledge graph vs vector database.

Vocabulary

A published set of classes and properties with defined meanings and IRIs, such as schema.org, FOAF, Dublin Core or SKOS. Reusing one connects a dataset to everything else that uses it, while minting a new term isolates the data that uses it. “Vocabulary” and “lightweight ontology” often refer to the same artifact; “ontology” implies more formal axioms. See ontologies.

W

Wikidata

The Wikimedia Foundation’s collaboratively edited knowledge graph, launched in October 2012, in which items carry Q-IDs, properties carry P-IDs, and every statement can carry qualifiers and references. The data is published under CC0, available as RDF dumps, and queryable through a public SPARQL endpoint, which makes it the most reused public knowledge graph and the most useful sameAs target. Items must satisfy notability rules, which are looser than Wikipedia’s but not absent. See Wikidata.

Wikidata Query Service

The public SPARQL endpoint for Wikidata, with a query editor at query.wikidata.org and a machine endpoint at query.wikidata.org/sparql, both free and needing no account. It predeclares Wikidata’s prefixes and offers a label service that fetches human-readable names, which is why Wikidata queries look shorter than general SPARQL. Queries are subject to a timeout, so broad patterns need narrowing. See Wikidata Query Service.

X

xsd

The conventional prefix for the XML Schema datatypes namespace, http://www.w3.org/2001/XMLSchema#, which supplies the datatypes RDF literals are typed with: xsd:string, xsd:integer, xsd:decimal, xsd:date, xsd:boolean, xsd:dateTime. Typing a literal with one of these is what lets a SPARQL query sort or compare it as a number or a date rather than as text.

FAQ

What is the difference between a knowledge graph and an ontology?

An ontology is the schema: the classes, properties, and rules that say what kinds of things exist and how they may relate. A knowledge graph is the data: the individual entities and the statements about them, usually organized by an ontology. An ontology with no instance data is a vocabulary; a graph of instance data with no ontology is a pile of edges nobody can interpret consistently.

What is a Q-ID and how does it relate to a Google MID?

A Q-ID is Wikidata’s identifier for an item, such as Q7186 for Marie Curie, and a MID is Google’s opaque identifier for an entity in its own knowledge graph, such as /m/0dl567. They are separate schemes maintained by separate organizations. Wikidata stores a Freebase ID for many older items, which supports partial reconciliation, but there is no complete crosswalk and no way to request a MID.

Is RDF the same thing as a property graph?

No. RDF is a triple model in which subjects and predicates are IRIs and edges carry no data of their own, while a labeled property graph stores nodes and edges as records with their own property maps. RDF wins on global identifiers and merging across datasets; a property graph wins when facts about relationships need somewhere to live. Reification and RDF-star close part of the gap.

Do I need to understand RDF to do entity SEO?

Not in depth, but the model explains the tactics. A schema.org JSON-LD block is a set of triples, @id is the subject, each property key is a predicate IRI, and sameAs links one IRI to another. Knowing that is why consistent identifiers matter more than repeated names, and why a property given the wrong kind of value produces a malformed statement rather than a stylistic problem.

Sources and further reading

W3C, RDF 1.1 Concepts and Abstract Syntax: https://www.w3.org/TR/rdf11-concepts/
W3C, SPARQL 1.1 Query Language: https://www.w3.org/TR/sparql11-query/
W3C, OWL 2 Web Ontology Language Primer: https://www.w3.org/TR/owl2-primer/
W3C, SKOS Simple Knowledge Organization System Primer: https://www.w3.org/TR/skos-primer/
schema.org, full type hierarchy: https://schema.org/docs/full.html
Wikidata, Introduction: https://www.wikidata.org/wiki/Wikidata:Introduction
Hogan et al., Knowledge Graphs: https://kgbook.org/