JSON-LD (JSON for Linked Data)

The core innovation of JSON-LD is its seamless integration with existing JSON ecosystems. It introduces a special @context object that maps simple JSON keys to globally unique IRIs (Internationalized Resource Identifiers) defined in ontologies. This allows standard JSON parsers to process the data while enabling semantic tools to interpret it as a fully-qualified RDF graph.

• The @context provides the vocabulary mapping, telling processors that a key like "name" actually means http://schema.org/name.
• Standard JSON tools (e.g., JSON.parse() in JavaScript) can read the data without modification.
• Semantic meaning is added without breaking existing code, enabling a gradual adoption path for Linked Data.

JSON-LD is a concrete implementation of Tim Berners-Lee's four Linked Data rules. It uses IRIs as names for things, expresses data as RDF triples, and includes links to other IRIs so that more things can be discovered.

• Use IRIs as names: Every entity and property is identified by a dereferenceable IRI, ensuring global uniqueness.
• Use HTTP IRIs: These IRIs can be looked up using the HTTP protocol to obtain more data (their definitions or related information).
• Provide useful RDF: When an IRI is dereferenced, it should return standard RDF data (like JSON-LD, Turtle).
• Include links to other IRIs: The data contains relationships to other entities, enabling the discovery of a web of connected data across different sources and domains.

JSON-LD can represent any RDF graph, including complex graphs with multiple interconnected nodes. It provides algorithms to convert between the RDF abstract model and JSON documents. A key feature is framing, which allows developers to shape the JSON tree structure according to a specific template.

• @graph Keyword: Used to explicitly express a set of nodes that may not have a natural hierarchical order in JSON.
• Framing: The process of taking a JSON-LD document and a frame (a pattern) to produce a new, predictable JSON layout. This is crucial for APIs that need a consistent JSON structure for consumption by front-end applications.
• Node Collapsing/Expansion: Algorithms can flatten a graph into a list of nodes or nest them based on subject references, providing flexibility in output format.

To keep JSON readable and concise, JSON-LD uses compact IRIs and allows the definition of a default vocabulary. A compact IRI has the form prefix:suffix, where the @context defines the expansion of prefix to a full IRI base.

• Prefix Definitions: "@context": { "schema": "http://schema.org/" } allows the use of "schema:name".
• Default Vocabulary: Setting a @vocab in the context allows unprefixed terms to be expanded automatically. For example, "@vocab": "http://schema.org/" means "name" expands to http://schema.org/name.
• Term Mapping: The context can also directly map a JSON key to any IRI, e.g., "@context": { "title": "http://purl.org/dc/terms/title" }. This decouples the JSON property name from the actual ontology term.

JSON-LD provides clear patterns for structuring data, choosing between embedding an object description inline or referencing it by its IRI. This mirrors common JSON design patterns while preserving graph semantics.

• Node Objects: An object with an @id is a node in the graph. Its properties describe that node.
• Embedded Nodes: A subject's properties can have values that are themselves full node objects, creating nested JSON structures.
• Referencing by @id: Instead of embedding, a property value can be a node reference, which is a JSON object containing only an @id. This creates a link in the graph without duplicating the target node's properties, essential for avoiding data duplication and linking to external resources.

JSON-LD serves as a primary serialization format for populating RDF-based knowledge graphs and triplestores. It allows developers to work with familiar JSON while producing standards-compliant RDF triples.

• Key Benefit: Lowers the barrier to entry for semantic web technologies by leveraging ubiquitous JSON tooling.
• Workflow: Data from various sources (databases, APIs) is transformed into JSON-LD documents with a defined @context, then bulk-loaded into a triplestore like GraphDB or Amazon Neptune for querying with SPARQL.

The @context mechanism allows for significant data compression in repetitive exchanges. Common prefixes and term mappings are defined once in the context, shrinking payload size.

• Key Benefit: Reduces network overhead for high-volume data streams while maintaining full semantic fidelity.
• Example: Instead of repeating long URLs, a context defines "skos": "http://www.w3.org/2004/02/skos/core#". The data can then use compact terms like "skos:prefLabel".

JSON-LD facilitates the integration of heterogeneous data from different domains by allowing the merging of contexts. Data from separate systems, each with its own @context, can be combined into a single, coherent graph.

• Key Benefit: Enforces semantic alignment at the data level, resolving naming conflicts and clarifying term meanings across sources.
• Process: A master context can import or override definitions from multiple source contexts, creating a unified namespace for consolidated queries and reasoning.

RDF is the foundational data model for the Semantic Web, representing information as a directed graph of subject-predicate-object triples. JSON-LD is a concrete syntax that serializes RDF graphs into JSON. While RDF defines the abstract graph model, JSON-LD provides a developer-friendly way to express it, using @context to map JSON keys to globally unique IRIs (Internationalized Resource Identifiers).

• Core Concept: Every piece of data is a statement (a triple) about a resource.
• Interoperability: Data from different sources can be merged if they use the same IRIs.
• Example: The triple <http://example.org/person/1> <http://schema.org/name> "Alice"> can be expressed in JSON-LD.

Linked Data refers to a set of best practices for publishing and connecting structured data on the web using RDF, URIs, and HTTP. JSON-LD is explicitly designed as a Linked Data format. The principles are:

1. Use URIs as names for things.
2. Use HTTP URIs so people can look up those names.
3. When someone looks up a URI, provide useful RDF/JSON-LD.
4. Include links to other URIs to discover more things.

JSON-LD's @context and use of URLs for properties inherently support these principles, enabling decentralized data ecosystems where datasets can link to and enrich each other.

SPARQL is the standard query language for RDF data. While JSON-LD is about data serialization, SPARQL is about data retrieval and manipulation. A SPARQL endpoint (an HTTP service) can query over data stored as JSON-LD once it is parsed into an RDF triplestore. Key query forms include:

• SELECT: Returns a table of results.
• CONSTRUCT: Creates a new RDF graph from query results.
• ASK: Returns a boolean yes/no answer.
• DESCRIBE: Returns an RDF graph describing a resource.

JSON-LD data can be the target of SPARQL queries and the output format for SPARQL SELECT results, often using the application/sparql-results+json media type.

A triplestore (or RDF store) is a purpose-built database designed for the storage and retrieval of RDF triples. It is the native storage backend for data serialized in formats like JSON-LD, Turtle, or RDF/XML. Key features include:

• Graph-Centric Storage: Optimized for traversing subject-predicate-object connections.
• SPARQL Support: Native execution of SPARQL queries for complex graph pattern matching.
• Inference Engines: Many triplestores can perform RDF inference, deriving new triples based on RDFS or OWL rules.

When JSON-LD is consumed by an application, it is typically parsed and loaded into a triplestore to enable efficient querying and reasoning.

OWL is a family of knowledge representation languages used to define rich, complex ontologies with formal, logical semantics. While JSON-LD can serialize the instance data (the "ABox"), OWL is used to define the schema (the "TBox")—classes, properties, and constraints. JSON-LD's @context can reference OWL ontologies to provide meaning to terms.

• Reasoning: OWL enables automated description logic reasoning to infer new facts and check consistency.
• Profiles: OWL 2 EL, QL, and RL are subsets optimized for specific scalability needs.
• Relationship: An OWL ontology provides the rigorous definitions that give JSON-LD data its precise, machine-interpretable meaning.