Open Knowledge Format as RDF Documents
RDF-Turtle and HTML documentation collection derived from Google Cloud introduction of Open Knowledge Format. It models an RDF document alternative to Markdown OKF bundles, including ontology classes, ontology properties, instance documents, comparison dimensions, Linked Data principles, SPARQL recipes, FAQ, glossary, and provenance.
Introducing the Open Knowledge Format
Google Cloud introduced Open Knowledge Format v0.1 as a vendor-neutral bundle of Markdown files with YAML frontmatter for portable agent and human knowledge.
RDF OKF Document Ontology
Lightweight ontology for representing OKF-style context bundles as RDF-Turtle documents instead of Markdown files.
Defines classes and properties for RDF document bundles, semantic documents, context atoms, comparison dimensions, SPARQL recipes, and Linked Data principles.
Ontology axiom examples
Concrete Turtle examples showing valid instance usage for every custom ontology class and property axiom.
RDF Knowledge Bundle
A deployable collection of RDF documents, ontologies, instance data, and query recipes that can be consumed by humans, agents, and SPARQL engines.
Semantic Document
A document whose identity, type, metadata, body sections, and relationships are represented as RDF triples.
Context Atom
A reusable unit of agent context such as a table, metric, runbook, API, dataset, join path, or concept.
Comparison Dimension
A criterion used to compare OKF Markdown documents with RDF-Turtle documents.
SPARQL Recipe
A saved query over the RDF document collection.
Linked Data Principle
A principle for naming, dereferencing, and interlinking entities on the Web.
denotes resource
Connects a semantic document or context atom to the entity it identifies.
has context atom
Connects a bundle or document to a reusable unit of context.
queryable by
Connects a bundle or entity group to a SPARQL recipe.
contrasts with
Connects one representation strategy to another in a comparison.
implements principle
Connects an RDF document pattern to a Linked Data principle.
Example: RDF Knowledge Bundle class axiom
Shows a valid bundle instance with semantic documents, context atoms, and SPARQL recipes.
:rdfBundle a :RdfKnowledgeBundle ; schema:hasPart :doc-sales-index ; :hasContextAtom :atom-bigquery-table ; :queryableBy :query-context-atoms .
Example: Semantic Document class axiom
Shows a semantic document instance denoting a reusable context resource.
:doc-orders-table a :SemanticDocument ; schema:name "sales/tables/orders.ttl"@en ; :denotesResource :resource-orders-table .
Example: Context Atom class axiom
Shows a context atom as a reusable unit of agent context inside the RDF bundle.
:atom-metric a :ContextAtom ; schema:name "Metric"@en ; schema:isPartOf :rdfBundle .
Example: Comparison Dimension class axiom
Shows a comparison dimension contrasting the Markdown and RDF-Turtle representation patterns.
:dim-query a :ComparisonDimension ; schema:name "Query model"@en ; :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .
Example: SPARQL Recipe class axiom
Shows a query recipe typed as both the local class and schema.org source code.
:query-context-atoms a :SparqlRecipe, schema:SoftwareSourceCode ; schema:programmingLanguage "SPARQL"@en ; schema:target <https://linkeddata.uriburner.com/sparql> .
Example: Linked Data Principle class axiom
Shows a Linked Data principle represented as a reusable defined term in the collection.
:principle-http-iris a :LinkedDataPrinciple ; schema:name "Use HTTP IRIs as names"@en ; schema:isPartOf :linkedDataPrinciples .
Example: denotes resource property axiom
Shows the domain/range intent: a semantic document denotes a context atom.
:doc-orders-table :denotesResource :resource-orders-table .
Example: has context atom property axiom
Shows the domain/range intent: a bundle contains a reusable context atom.
:rdfBundle :hasContextAtom :atom-bigquery-table .
Example: queryable by property axiom
Shows the domain/range intent: a bundle is queryable by a SPARQL recipe.
:rdfBundle :queryableBy :query-context-atoms .
Example: contrasts with property axiom
Shows the comparison relationship between a dimension and the two representation patterns.
:dim-query :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .
Example: implements principle property axiom
Shows an RDF document pattern implementing Linked Data principles.
:rdfTurtlePattern :implementsPrinciple :principle-http-iris .
Sam McVeety
Tech Lead, Data Analytics, Engineering, Data Cloud, Google Cloud, and co-author of the source article.
Amir Hormati
Tech Lead, BigQuery, Engineering, Data Cloud, Google Cloud, and co-author of the source article.
Google Cloud
Publisher of the Open Knowledge Format article and related data analytics tooling.
BigQuery
Google Cloud analytics platform mentioned through the OKF enrichment-agent reference implementation.
Google Cloud Knowledge Catalog
Google Cloud catalog system updated to ingest Open Knowledge Format and serve it to agents.
OKF Markdown document pattern
The source article describes OKF v0.1 as a directory of Markdown files with YAML frontmatter fields including type, title, description, resource, tags, and timestamp.
RDF-Turtle document pattern
This collection demonstrates an alternate pattern where each document is Turtle, every concept has an IRI, relationships are typed predicates, ontology terms are declared, and SPARQL recipes query the bundle.
RDF OKF sales context bundle
A sample RDF-Turtle bundle mirroring the article sales directory example with index, datasets, tables, metrics, and runbooks represented as semantic documents.
Collection index for the sales context bundle.
sales/index
Dataset profile for the sales orders database.
sales/datasets/orders_db
Table profile for completed customer orders.
sales/tables/orders
Table profile for customer records.
sales/tables/customers
Metric definition and lineage for weekly active users.
sales/metrics/weekly_active_users
Runbook context for agent-assisted incident response.
ops/runbooks/incident_response
BigQuery table
A data warehouse table represented as a typed entity with schema, resource URL, owners, and relationships.
Dataset
A collection of tables, views, or data products with ownership and usage metadata.
Metric
A reusable business measure with a formula, provenance, grain, source tables, and governance notes.
Join path
A relationship showing how two data entities are connected by keys or graph predicates.
Runbook
Operational instructions that agents can retrieve, traverse, and update.
API
A service interface represented as a discoverable entity with operations and examples.
Provenance record
A trace of source, author, timestamp, and derivation for a context atom.
Relevant context limits agentic systems
Foundation models can write code, summarize documents, and analyze data, but accurate action still depends on context.
OKF formalizes the LLM-wiki pattern
OKF v0.1 turns a directory of Markdown files with YAML frontmatter into a portable, vendor-neutral knowledge format.
Enterprise context is fragmented
Schemas, metrics, runbooks, APIs, joins, code comments, documents, and expert memory live across incompatible surfaces.
The problem needs a format, not another service
OKF emphasizes producer and consumer independence over a new runtime, SDK, or proprietary platform.
OKF uses file paths as concept identity
In the v0.1 design, each Markdown file represents a concept and the file path is the concept identity.
Markdown links make a graph
Concept documents link to each other with Markdown links, creating richer relationships than the directory tree alone.
OKF is a starting point
The specification is intentionally versioned, open, and expected to evolve as producers and consumers appear.
RDF upgrades path identity to Web identity
RDF-Turtle documents can use HTTP IRIs for concepts, allowing names to remain stable across repositories, products, and organizations.
RDF turns links into typed relationships
Markdown links say that two pages are connected; RDF predicates say how the entities are connected.
SPARQL makes the document collection queryable
SPARQL can query claims, types, provenance, relationships, and document metadata without bespoke parsers for every repository convention.
Ontologies support explicit schema evolution
RDF can publish classes and properties alongside instance data so extensions are visible and reusable.
Linked Data makes context portable beyond a bundle
Dereferenceable IRIs let a context atom join public or private graphs without translation into a vendor catalog schema.
Turtle remains inspectable text
RDF-Turtle keeps a readable text-file workflow while adding formal semantics, validation options, and graph querying.
OKF Markdown vs RDF-Turtle comparison
Identity
OKF Markdown: file path is identity. RDF-Turtle: HTTP IRIs identify entities independent of local storage paths.
Relationship semantics
OKF Markdown: links are readable but mostly untyped. RDF-Turtle: predicates make relationships explicit and machine-actionable.
Query model
OKF Markdown: search tools and conventions. RDF-Turtle: SPARQL over typed triples, named graphs, provenance, and ontology terms.
Portability
OKF Markdown: portable files and Git repositories. RDF-Turtle: portable files plus Web-scale entity references and graph federation.
Validation
OKF Markdown: frontmatter fields and repository rules. RDF-Turtle: parser validation plus optional SHACL and ontology constraints.
Schema evolution
OKF Markdown: conventions evolve through spec versions. RDF-Turtle: ontologies publish classes and properties that can be extended incrementally.
Human authoring
OKF Markdown: familiar writing workflow. RDF-Turtle: more structured, but still text-based and readable when authored carefully.
Agent consumption
OKF Markdown: agents parse directories and frontmatter. RDF-Turtle: agents traverse typed graphs and execute SPARQL queries.
Linked Data principles for RDF OKF
Use HTTP IRIs as names
Things should be named with HTTP IRIs so people and agents can refer to the same entity across documents and systems.
Dereference names into descriptions
Looking up an IRI should lead to useful information about the named entity.
Describe things with RDF
Descriptions should use RDF statements so data from many sources can merge into one graph.
Include links to other things
RDF should connect entities to other IRIs so graph discovery and reuse improve over time.
Benefits of RDF, Linked Data, and SPARQL
Global joinability
A table, metric, runbook, and API can be related through IRIs rather than trapped in one repository tree.
Precise relationship meaning
Predicates distinguish schema:about, schema:isPartOf, prov:wasDerivedFrom, okfx:denotesResource, and business-specific links.
Cross-document questions
SPARQL can ask which metrics depend on a deprecated table or which runbooks mention a failing API.
Provenance as data
Authors, publication dates, derivations, source URLs, and generation steps can be queried rather than hidden in prose.
Agent planning substrate
Agents can traverse known relationships, inspect ontology terms, and choose next actions from graph shape.
No required SDK
Like OKF, Turtle files can live in Git, tarballs, object stores, or WebDAV, while remaining more formally queryable.
FAQ: OKF as RDF documents
What did Google Cloud introduce?
Google Cloud introduced Open Knowledge Format v0.1, an open specification for representing agent and human knowledge as Markdown documents with YAML frontmatter.
What problem does OKF address?
OKF addresses fragmented enterprise context: schemas, metrics, runbooks, APIs, joins, documents, and expert knowledge split across incompatible systems.
Why does this collection use RDF-Turtle instead of Markdown?
It demonstrates how the same document-collection idea can be represented as linked, typed RDF documents with ontology and instance data.
What is the main benefit of RDF over Markdown links?
RDF links are typed predicates between identified things, so an agent can know whether a link means about, depends on, joins to, derives from, or implements.
Does RDF replace OKF?
Not necessarily. RDF can be an alternate OKF serialization, an enrichment layer, or the source-of-truth format for teams that need graph queries and Linked Data interoperability.
Why are Linked Data principles important here?
Linked Data makes context atoms portable beyond a local folder by using dereferenceable IRIs and RDF descriptions that can join other graphs.
How does SPARQL improve agent consumption?
SPARQL gives agents a standard way to ask graph-shaped questions across documents, types, relationships, provenance, and examples.
What tradeoff does RDF introduce?
RDF-Turtle is more explicit and structured than Markdown, which improves machine actionability but requires more care in authoring and validation.
How can humans still read RDF docs?
Turtle is a text format with prefixes, compact triples, labels, comments, and descriptions; a companion HTML view can provide the friendly reading surface.
What should a practical RDF OKF bundle contain?
It should contain ontology terms, typed instance documents, provenance, cross-links, glossary terms, query recipes, and a small set of conformance rules.
Glossary: OKF RDF document collection
Open Knowledge Format
A Google Cloud open specification for portable Markdown-plus-frontmatter knowledge bundles for agents and humans.
RDF
A W3C graph data model based on subject, predicate, object statements.
RDF-Turtle
A compact, human-readable RDF serialization suitable for text-file document collections.
Linked Data
A set of Web practices for naming and interlinking things with dereferenceable IRIs and RDF descriptions.
SPARQL
The standard query language and protocol for RDF graphs.
Ontology
A published vocabulary of classes and properties that describes the meaning of graph data.
Named graph
An RDF graph identified by an IRI, useful for provenance, partitioning, and query scoping.
SHACL
A W3C constraints language that can validate RDF graphs against shape rules.
How to build an RDF-Turtle OKF-style bundle
Keep the folder bundle
Preserve OKF’s simple bundle shape: directories, index documents, and version control still work for RDF-Turtle files.
Mint stable IRIs
Give every concept, metric, table, runbook, and API a durable HTTP IRI rather than relying only on a local file path.
Declare the ontology
Publish classes and properties for bundle, document, context atom, comparison dimension, and query recipe terms.
Write instance data
Represent each document as a named entity with type, title, description, source resource, tags, timestamps, and typed relationships.
Type every relationship
Replace ambiguous Markdown links with predicates such as schema:isPartOf, prov:wasDerivedFrom, okfx:denotesResource, and okfx:hasContextAtom.
Add SPARQL recipes
Store useful query patterns as first-class entities so agents can inspect, run, and adapt them.
Render HTML from RDF
Generate the human-friendly documentation view from the Turtle graph so prose and graph data stay aligned.
Validate the graph
Parse Turtle, test links, optionally apply SHACL shapes, and run example SPARQL queries before publishing.
SPARQL query layer for RDF OKF documents
List context atoms
SPARQL query recipe
PREFIX schema: <http://schema.org/> PREFIX okfx: <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#> SELECT ?atom ?name ?description WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/open-knowledge-format-rdf-docs-gpt5-chat-1.ttl> { ?atom a okfx:ContextAtom ; schema:name ?name ; schema:description ?description . } } ORDER BY ?name
Compare OKF and RDF dimensions
PREFIX schema: <http://schema.org/> PREFIX okfx: <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#> SELECT ?dimension ?name ?description WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/open-knowledge-format-rdf-docs-gpt5-chat-1.ttl> { ?dimension a okfx:ComparisonDimension ; schema:name ?name ; schema:description ?description . } } ORDER BY ?name
Find semantic documents and resources
PREFIX schema: <http://schema.org/> PREFIX okfx: <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#> SELECT ?doc ?name ?resource WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/open-knowledge-format-rdf-docs-gpt5-chat-1.ttl> { ?doc a okfx:SemanticDocument ; schema:name ?name . OPTIONAL { ?doc okfx:denotesResource ?resource } } } ORDER BY ?name
is based on
author
publisher
mentions
defines class
defines property
has example
example of
has semantic document
compares by
has benefit
depends on
about