Knowledge Graph-Driven Retrieval Augmented Generation (RAG)

We are pleased to announce the immediate availability of the OpenLink Personal Assistant, a practical application of Knowledge Graph-driven Retrieval Augmented Generation (RAG) showcasing the power of knowledge discovery and exploration enabled by a modern conversational user interface. This modern approach revitalizes the enduring pursuit of high-performance, secure data access, integration, and management by harnessing the combined capabilities of Large Language Models (LLMs), Knowledge Graphs, and RAG, all propelled by declarative query languages such as SPARQL, SQL, and SPASQL (SPARQL inside SQL).

Let’s delve into what the OpenLink Assistant enables.

Core Components

Large Language Models (LLMs)

GPT 4.0 and 3.5-turbo foundation models form the backbone of the OpenLink Assistant, offering a sophisticated level of conversational interaction. These models can interpret context, thereby providing a user experience that intuitively emulates aspects of human intelligence.

RAG Technology Infused with Query Languages

What truly sets OpenLink Assistant apart is state-of-the-art RAG technology, integrated seamlessly with SPARQL, SQL, and SPASQL (SPARQL inside SQL). This fusion, coupled with our existing text indexing and search functionality, allows for real-time, contextually relevant data retrieval from domain-specific knowledge bases deployed as knowledge graphs.

Key Features

1. Self-Describing, Self-Supporting Products: OpenLink Assistant adds a self-describing element to our Virtuoso, ODBC & JDBC Drivers products by simply installing the Assistant’s VAD (Virtuoso Application Distro) package.
2. OpenAPI-Compliance: With YAML and JSON description documents, OpenLink Assistant offers hassle-free integration into existing systems. Any OpenAPI compliant service can be integrated into its conversation processing pipeline while also exposing core functionality to other service consumer apps.
3. Device Compatibility: Whether you’re on a desktop or a mobile device, OpenLink Assistant delivers a seamless interaction experience.
4. UI Customization: The Assistant can be skinned to align with your application’s UI, ensuring a cohesive user experience.
5. Versatile Query Support: With support for SQL, SPARQL, and SPASQL, OpenLink Assistant can interact with a multitude of data, information, and knowledge sources.

What’s In It For You?

1. Enhanced Efficiency: LLM and RAG technologies, fortified with query languages, streamline data retrieval, enabling quicker, more informed decisions.
2. Contextual Relevance: Retrieve data that is not just accurate, but tailored to the specific context of your query, thanks to the RAG technology.
3. Robust Security: As with all OpenLink products, the Assistant upholds rigorous security standards.
4. Flexibility: With OpenAPI compatibility and the VAD package, OpenLink Assistant offers unparalleled customizability and ease of integration.

In Summary

OpenLink Assistant isn’t just another product; it’s a paradigm shift in how we interact with data and software tools. Leveraging knowledge graph-based RAG as the foundation for adding conversational self-support to existing applications simplifies and enriches user engagement, knowledge development, and knowledge retention.

For further details, please you can visit any of the following links:

• Personal Assistant Session Transcript Example 1
• Live OpenLink Assistant Instance — usage requires presentation of your OpenAI Key
• Personal Assistant Usage Guide 2
• Personal Assistant Screencast Demo 2
• Download OpenLink Assistant VAD Package 1
• OpenLink Assistant Usage Guide
• Leveraging LLM-Based Conversational Assistants (Bots) for Enhanced Software Interaction

Introducing the OpenLink Personal Assistant was originally published in OpenLink Software Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Large Language Models (LLM) technology is revolutionizing the software landscape, introducing dynamic natural language processors and code generators. In this article, we delve deep into how LLMs can significantly enhance software development and usability, focusing on the pivotal areas outlined below:

1. Typing & Typos
2. Command Syntax Precision
3. Product Documentation & Help
4. Self-Help Support
5. Functionality Demonstrations

1. Typing & Typos

The Enduring Challenge of Command-Oriented Interfaces

Command-oriented interfaces are often hampered by typographical errors, where a single typo can lead to incorrect outcomes or halt operations.

Solution

LLM bots facilitate intelligent error detection and correction, reducing disruptions caused by typos.

Example: An LLM-based bot can autocorrect as part of its prompt processing pipeline; for instance, the prompt “retrive customer details” is automatically corrected to “retrieve customer details,” thereby ensuring uninterrupted operation.

2. Command Syntax Precision

The Necessity for Syntax Precision in Traditional Interfaces

Traditional command interfaces require meticulous adherence to syntax rules, presenting a steep learning curve for users.

Solution

LLM bots offer flexibility in command inputs, allowing users to issue commands in natural language.

Example: Instead of remembering the exact command syntax of a declarative query language (e.g., SQL or SPARQL), a user can type “Find orders and associated product details for customer ALFKI,” and the LLM can translate it to the correct query language command syntax.

3. Revolutionizing Product Documentation & Help

The Hurdles of Conventional Documentation

Navigating product documentation has always been a challenge due to poorly written or excessively voluminous material.

Solution

LLM bots can generate concise and user-friendly responses to functionality usage questions. They leverage Retrieval Augmented Generation (RAG) techniques for loosely coupled integration with document databases and knowledge bases.

Example: A user can ask “How do I set up a macro?” and an LLM bot will provide a step-by-step guide drawn from the product’s documentation corpus.

4. Amplifying Self-Help Product Support

The Limitations of Earlier Bots in Inference

Earlier bots often struggled to provide effective self-help solutions, limited by their inability to understand a range of syntactic patterns expressing the same semantic meaning.

Solution

LLM bots enhance the domain of product support by offering more accurate responses to a wider array of sentence patterns.

Example: In spreadsheet software, a user might ask, “How do I sum values in a column?” The LLM can then guide the user through the process, effectively understanding the user’s intent.

5. Efficient Functionality Demonstrations with LLM

The Traditional Struggle with Demonstrations

Demonstrations were often hampered by the varying levels of expertise (and interests) in the audience, resulting in either oversimplified or overly complicated presentations, which posed challenges for both the demonstrator and their audience.

Solution

LLM bots can dynamically showcase software functionality in response to natural language prompts, offering guided walkthroughs tailored to the user’s current tasks or explicit requests. Moreover, they can deliver deeper, interactive product demonstrations where users control the subject-area focus.

Example: During a demonstration, an LLM bot can field questions from the audience and provide real-time, tailored demonstrations based on natural language queries, ensuring everyone leaves with a deep understanding of the functionalities discussed.

Workflow for Optimal Use of LLM-based Conversational Bots

To integrate LLMs into operations successfully, consider the following simplified workflow:

1. Identify crucial data sources, including databases and knowledge bases.
2. Create a virtualization layer using hyperlinks to formulate a “web of data” or “knowledge graph” for machine-readable entity-relationship semantics.
3. Document the virtualization layer with HTML.
4. Integrate the virtualization layer with your LLM bot using SQL or SPARQL.
5. Foster a human-reinforced feedback loop as part of LLM bot interactions, iterating as necessary.

Conclusion

LLMs are at the forefront of revolutionizing software development and utilization, addressing long-standing challenges and forging a pathway towards a more inclusive, efficient, and user-friendly software landscape.

Further Reading

• The data dividend: Fueling generative AI
• Transformer Aspect of LLMs Explained
• SPARQL Plugin for ChatGPT
• Using SPARQL Query Templates to Fine-Tune ChatGPT’s Large Language Model (LLM) 1
• Other Posts & HowTo Guides

Leveraging LLM-Based Conversational Assistants (Bots) for Enhanced Software Interaction was originally published in OpenLink Software Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

A response generated by ChatGPT regarding the effects of leveraging its conversational UI/UX as the missing interface for understanding and appreciating the virtues of a Semantic Web constructed using Linked Data principles:

I completely agree with you. The combination of natural language processing and linked open data (LOD) presents a unique opportunity to create sophisticated conversational interfaces that can access and interact with a wealth of domain-specific knowledgebases.

These knowledgebases, curated by domain experts and deployed using Linked Data principles, represent a vast, interconnected web of information that spans virtually every field of human knowledge. Leveraging this resource effectively can greatly enhance the capabilities of AI systems, allowing them to provide more accurate and contextually relevant information.

However, the potential of this resource remains largely untapped, as the user experience of interacting with these knowledgebases is often not intuitive or user-friendly. This is where a conversational UI/UX can make a significant difference.

By providing a natural, human-like interface to these knowledgebases, a conversational UI/UX can make it easier for users to access and interact with the information contained within them. This not only improves the user experience, but also increases the utility of these knowledgebases by making them more accessible to a wider audience.

In this way, the development of advanced conversational interfaces can play a key role in realizing the full potential of the semantic web and linked data principles.

In this post, I explore the symbiotic relationship between Large Language Models (LLMs)-driven conversational bots like ChatGPT and the concept of a Semantic Web (public, private, or hybrid)[1]. This symbiosis exists due to the reasons outlined in the ChatGPT response above, which can be summarized as follows:

1. LLMs provide a foundation for powerful natural language processing based on their understanding of sentence syntax and semantics; for instance, they comprehend the underlying semantics of multiple variations of the same sentence.
2. A Semantic Web is simply a variation of the Web explicitly constructed from sentences using hyperlinks to express sentence syntax and semantics in machine-computable form; the net effect is a boundless collective of structured data that manifests a global entity relationship graph (rather than network), comprising machine-computable entity relationship type semantics.

Large Language Models (LLMs)

Computer User Interface Challenges

Interfaces for interacting with computers have remained a significant challenge for a long time. Initially, command-line interfaces attempted to address this challenge, but their usability was hampered by the need for users to master specific sentence syntax. This evolved, following innovations originating from Xerox Parc (popularized by Apple and later Microsoft), into widget-based interactions that introduced the Graphical User Interface. Unfortunately, neither approach to user-interface and user-interaction fully addressed the need for more natural interface and interaction modalities that incorporated natural language input via typing, images, or sound. The net effect, as demonstrated in today’s mobile phone-dominated era, is that access to powerful personal computing has negatively impacted basic human social behavior. For instance, both the young and old in today’s world often find it hard to hold a conversation (in any setting) without the distraction of a mobile phone due to its dependency on a user-interface and user-interaction modality that is still primarily based on typing as the primary interaction mechanism.

The challenges of natural language processing are at the root of today’s computer interaction dysfunctionality. For example, command-line interfaces are suboptimal due to their rigid requirements for sentence structure and syntax. There is only one rigid structure (despite support for argument-based switches) for constructing a command that’s comprehensible to a target application or an operating system. With GUIs, the power and specificity of sentences are replaced by a primitive collection of interaction widgets that merely masquerade as solutions to the underlying interaction issues. Often, they erode productivity and utility in their quest to oversimplify task execution.

Addressing Natural Language Challenge

In recent times, Large Language Models (LLMs) have emerged as a potential solution to the long-standing natural language processing issues that have plagued computing to date. They address this problem through the use of training sets that enable the simulated comprehension of sentence structure, syntax, and underlying semantics. In a nutshell, they allow a multitude of sentence variations to be accurately mapped to a specific interpretation, which can be associated with specific task execution — this is a game-changing development.

Challenges

Despite the game-changing innovation they bring to natural language processing, it is no secret that the growth in the size of LLM models has already hit its tipping point [2]. The same goes for their tendency to hallucinate, given the fluid nature of data, information, and knowledge.

Fundamentally, while LLMs enable powerful and innovative natural language processing, they should never be mistaken for reliable knowledge bases.

Semantic Web Backgrounder

Challenges

It is also no secret that the notion of a Semantic Web has been riddled with controversy since its introduction in 2001 via a scientific america article authored by Tim Berners-Lee, Jim Hendler, and Ora Lassila.

The aspirational view of the Web, at the time of the article’s presentation, anticipated what we are witnessing today, i.e., a Web composed of structured data that also harnesses the power of logic conveyed in natural language. Similar to the Web itself during its initial introduction, such a novel concept was challenging for many to comprehend, let alone accept.

As a bottom-up effort, the task of engaging developers and the emergence of productivity tools also presented significant challenges.

Semantic Web Today

LOD Cloud

The ideas behind the Semantic Web are now available through what’s known as the Linked Open Data Cloud (LOD Cloud). The LOD Cloud is a large and decentralized collection of knowledge graphs, each one carefully curated by domain experts. It comprises structured data crafted using RDF-based sentences. In these sentences, hyperlinks denote the subjects and predicates, while either hyperlinks or literals (typed or untyped) denote the objects. The LOD Cloud also includes SPARQL query service endpoints, which enhance its data connectivity and provide greater flexibility. SPARQL, a powerful query language, is deeply integrated with HTTP. This means that both queries and their solutions can be encoded as hyperlinks, further enhancing the versatility of the LOD Cloud!

LOD Cloud Version 1.0 Depiction (circa 2007)

LOD Cloud Growth Depiction

LOD Cloud Today Depiction (Today)

Schema.org and Semantic SEO (SSEO)

In recent times, courtesy of Schema.org and broad support from Google, another Semantic Web frontier has opened up, reflecting the gradual transition from keyword-based search engine optimization (SEO) to semantic search engine optimization (SSEO). By creating a high-level vocabulary (schema or ontology) for the Web, Schema.org has introduced the following growth factors:

1. Major vendor support: This is delivered by Google, Microsoft, Yandex, and other search engine service providers.
2. Simple vocabulary: It’s compatible with the needs of Web Developers and SEO practitioners.
3. Demonstrable adoption and growth: This is seen through initiatives such as Web Data Commons, a derivative of the Common Crawl effort widely used as training data for LLMs.
4. Strong support of JSON-LD: As a structured data representation format, it effectively combines the ubiquity of JSON with the power of Linked Data Principles.

Schema.org Induced SSEO Growth

ActivityPub based Fediverse

In addition to what’s been covered so far, there’s also a frontier in social media, known as the Fediverse. This new space leverages the unobtrusive power of JSON-LD to expose the virtues of a Semantic Web. This is done via ActivityStreams documents, which are moved across inboxes and outboxes using the ActivityPub protocol. The Fediverse particularly appeals to those seeking decentralized social media, where user identity, follower networks, and content can be transferred between platforms. Much like the LOD Cloud and SSEO frontier driven by Schema.org, the Fediverse has already passed the point of critical mass regarding network effects, as illustrated below.

Fundamentally, the Semantic Web concept has been challenged by the lack of a complementary interface that manifests its underlying value to both end-users and developers alike. The nature of this interface must go beyond conventional UI/UX constructed using buttons, fields, and dialogs that drive traditional application UI/UX.

Thermonuclear Fusion of LLMS & a Semantic Web

Today, on one side, we see widespread acceptance and extensive use of LLM-powered natural language processors. On the other side, there’s a stealthily growing Semantic Web, which comprises a vast collection of knowledge graphs curated by domain experts. LLMs encounter challenges with hallucinations, issues that are significantly mitigated when domain-specific knowledge graphs are loosely integrated. In the same vein, the conversational UI/UX offered by LLM-powered chatbots (e.g., ChatGPT) presents a powerful solution to the end-user and developer uptake challenges that have challenged the Semantic Web concept for years.

Combining the power of LLMs and a Semantic Web (public, private, or hybrid) unleashes a thermonuclear fusion effect that completely redefines the nature of computing as we’ve all experienced it to date. Why? Because language, mankind’s greatest innovation [3], is now fully integrated into computing like never before. For instance, conversational UI/UX using natural language sentences is replacing primitive buttons, dialogs, and forms as the prime interaction infrastructure. In addition, we have the benefit of expressing computer interactions through the manipulation of entities, entity types, and entity relationship types. This spans all the way down from knowledge, through information, to raw data. This transformative change is happening due to the convergence of two powerful realms. Both realms are driven by the power of language for encoding and decoding information using signs, syntax, and semantics.

Conclusion

“Data is a new kind of electricity conducted by hyperlinks” is a statement I made years ago at the advent of the Linked Open Data cloud. That was a time when the use of Linked Data Principles for structured data representation ushered in a practical and reoriented approach to the concept of a Semantic Web.

Today, thanks to technologies like ChatGPT, we have reached a critical milestone in a journey spanning over 20 years. Software now has the ability to emulate understanding what operators (be they users or developers) mean in the course of operational interactions. This has all been facilitated by the unique and powerful data connectivity provided by hyperlinks, the same magical component that enabled the World Wide Web.

In this new computing frontier, we can now address critical issues such as:

1. Decentralized & Pseudonymous Self-Sovereign Identity Authenticity.
2. Privacy that scales to both the Internet and Web.
3. Exploiting the power of Language, at both Internet and Web scales.
4. Building Smart Agents equipped with progressive intelligence that serve line-of-business needs such as Customer Support, Business Development, etc.
5. Driving Enterprise Agility without ripping and replacing existing infrastructure i.e., eradicating rather than compounding technical debt.

Related Links

1. Linked Data, Ontologies, and Knowledge Graphs
2. A Semantic Web & Artificial Intelligence
3. Sam Altman — Size of LLMs won’t Matter as much Going Forward
4. Buzzwords, Language, and Information Access
5. Semantic Web — Scientific America Article [PDF]
6. LOD Cloud SPARQL Query Service Endpoints Spreadsheet
7. Beware Tunnel Vision in AI Retrieval
8. Edges of Knowledge by Rémy Fannader
9. Linked Data Spaces & Data Portability
10. Friend of a Friend: The Facebook That Could Have Been

Additional Related Information

• ChatGPT Fine-tuning using SPARQL Query Templates
• ChatGPT Fine-tuning using SQL Query Templates
• Using ChatGPT to Query across the Web using SPARQL
• ChatGPT based Technical Support Agent for Virtuoso
• Things Can’t Do Without A Semantic Web

ChatGPT and Semantic Web Symbiosis was originally published in OpenLink Virtuoso Weblog on Medium, where people are continuing the conversation by highlighting and responding to this story.

This post showcases the use of Mermaid’s visual notation for presenting an Entity Relationship Model Diagram that’s ultimately used as the basis for generating a Knowledge Graph deployed using Linked Data Principles that’s immediately viewable and browsable from any web browser that includes the OpenLink Structured Data Sniffer Browser Extension.

Here are the steps for achieving the goal outlined above.

Create Entity Relationship Model using Mermaid’s Visual Notation.

Here’s a simple entity relationship model example covering the following classes: Customer, Delivery Address, Order, Order Item, Invoice, Product, and Product-Category.

CUSTOMER }|…|{ DELIVERY-ADDRESS : has
CUSTOMER ||–o{ ORDER : places
CUSTOMER ||–o{ INVOICE : “liable for”
DELIVERY-ADDRESS ||–o{ ORDER : receives
INVOICE ||–|{ ORDER : covers
ORDER ||–|{ ORDER-ITEM : includes
PRODUCT-CATEGORY ||–|{ PRODUCT : contains
PRODUCT ||–o{ ORDER-ITEM : “ordered in”

Model Visualization

CHAT-GPT Session Transcript

Q: Generate an ontology using RDF-Turtle for the text that follows, using the following guidelines:

1. Denote subjects and objects using relative hash-based hyperlinks i.e., negating the use of example.com
2. Output response to a code-block
3. Place ## Turtle Start ## and ## Turtle End ## around the code within the code-block

CUSTOMER }|…|{ DELIVERY-ADDRESS : has
CUSTOMER ||–o{ ORDER : places
CUSTOMER ||–o{ INVOICE : “liable for”
DELIVERY-ADDRESS ||–o{ ORDER : receives
INVOICE ||–|{ ORDER : covers
ORDER ||–|{ ORDER-ITEM : includes
PRODUCT-CATEGORY ||–|{ PRODUCT : contains
PRODUCT ||–o{ ORDER-ITEM : “ordered in”

A:

@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

:Customer rdfs:subClassOf :Customer .
:DeliveryAddress rdfs:subClassOf :DeliveryAddress .
:Order rdfs:subClassOf :Order .
:Invoice rdfs:subClassOf :Invoice .
:OrderItem rdfs:subClassOf :OrderItem .
:ProductCategory rdfs:subClassOf :ProductCategory .
:Product rdfs:subClassOf :Product .
:has rdfs:domain :Customer ;
    rdfs:range :DeliveryAddress .
:places rdfs:domain :Customer ;
    rdfs:range :Order .
:liableFor rdfs:domain :Customer ;
    rdfs:range :Invoice .
:receives rdfs:domain :DeliveryAddress ;
    rdfs:range :Order .
:covers rdfs:domain :Invoice ;
    rdfs:range :Order .
:includes rdfs:domain :Order ;
    rdfs:range :OrderItem .
:contains rdfs:domain :ProductCategory ;
    rdfs:range :Product .
:orderedIn rdfs:domain :Product ;
    rdfs:range :OrderItem .

Q: Are the rdfs:subClassOf triples necessary?
A:
Apologies for the confusion. You are correct; the rdfs:subClassOf triples are not necessary in this case. They are used to define a class hierarchy, which is not needed for this specific ontology. Here’s the corrected Turtle syntax without the rdfs:subClassOf triples:

## Turtle Start ##
@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
:has rdfs:domain :Customer ;
    rdfs:range :DeliveryAddress .

:places rdfs:domain :Customer ;
    rdfs:range :Order .

:liableFor rdfs:domain :Customer ;
    rdfs:range :Invoice .

:receives rdfs:domain :DeliveryAddress ;
    rdfs:range :Order .

:covers rdfs:domain :Invoice ;
    rdfs:range :Order .

:includes rdfs:domain :Order ;
    rdfs:range :OrderItem .

:contains rdfs:domain :ProductCategory ;
    rdfs:range :Product .

:orderedIn rdfs:domain :Product ;
    rdfs:range :OrderItem .
## Turtle End ##

Q: Can you generate 3 sample product class instances?
A:
Certainly! Here are three sample product class instances in Turtle syntax:

## Turtle Start ##
@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

:Product1 a :Product ;
    rdfs:label "Laptop" ;
    :price 1200 ;
    :category "Electronics" .
:Product2 a :Product ;
    rdfs:label "Mountain Bike" ;
    :price 800 ;
    :category "Sports Equipment" .
:Product3 a :Product ;
    rdfs:label "Novel: The Catcher in the Rye" ;
    :price 15 ;
    :category "Books" .
## Turtle End ##

In this example, I have created three instances of the :Product class, each with a label, price, and category. You can customize the properties and values as needed for your specific use case.

Q: Can you generate 3 Customer instances?
A:
Certainly! Here are three sample customer instances in Turtle syntax:

## Turtle Start ##
@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

:Customer1 a :Customer ;
    rdfs:label "Alice" ;
    :email "alice@example.com" ;
    :phone "555-123-4567" .

:Customer2 a :Customer ;
    rdfs:label "Bob" ;
    :email "bob@example.com" ;
    :phone "555-987-6543" .

:Customer3 a :Customer ;
    rdfs:label "Charlie" ;
    :email "charlie@example.com" ;
    :phone "555-246-8101" .
## Turtle End ##

In this example, I have created three instances of the :Customer class, each with a label, email, and phone number. You can customize the properties and values as needed for your specific use case.

Q: Can you generate product category instances for each of the sample products?
A:
Sure! Here are the :ProductCategory instances for each of the sample products:

## Turtle Start ##
@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

:ElectronicsCategory a :ProductCategory ;
    rdfs:label "Electronics" .

:SportsEquipmentCategory a :ProductCategory ;
    rdfs:label "Sports Equipment" .

:BooksCategory a :ProductCategory ;
    rdfs:label "Books" .

:Product1 a :Product ;
    rdfs:label "Laptop" ;
    :price 1200 ;
    :category :ElectronicsCategory .

:Product2 a :Product ;
    rdfs:label "Mountain Bike" ;
    :price 800 ;
    :category :SportsEquipmentCategory .

:Product3 a :Product ;
    rdfs:label "Novel: The Catcher in the Rye" ;
    :price 15 ;
    :category :BooksCategory .
## Turtle End ##

In this example, I have created three instances of the :ProductCategory class and assigned them to the sample products using the :category property.

Q: Can you create a delivery address for each sample Customer?
A:
Certainly! Here’s the Turtle syntax with :DeliveryAddress instances for each sample customer:

## Turtle Start ##
@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

:Customer1 a :Customer ;
    rdfs:label "Alice" ;
    :email "alice@example.com" ;
    :phone "555-123-4567" ;
    :has :DeliveryAddress1 .

:Customer2 a :Customer ;
    rdfs:label "Bob" ;
    :email "bob@example.com" ;
    :phone "555-987-6543" ;
    :has :DeliveryAddress2 .

:Customer3 a :Customer ;
    rdfs:label "Charlie" ;
    :email "charlie@example.com" ;
    :phone "555-246-8101" ;
    :has :DeliveryAddress3 .

:DeliveryAddress1 a :DeliveryAddress ;
    rdfs:label "Alice's Address" ;
    :street "123 Main St" ;
    :city "New York" ;
    :state "NY" ;
    :postalCode "10001" .

:DeliveryAddress2 a :DeliveryAddress ;
    rdfs:label "Bob's Address" ;
    :street "456 Oak St" ;
    :city "Los Angeles" ;
    :state "CA" ;
    :postalCode "90001" .

:DeliveryAddress3 a :DeliveryAddress ;
    rdfs:label "Charlie's Address" ;
    :street "789 Pine St" ;
    :city "Chicago" ;
    :state "IL" ;
    :postalCode "60601" .
## Turtle End ##

In this example, I have created three instances of the :DeliveryAddress class and assigned them to the sample customers using the :has property.

Q: Can you generate a sample product order for each sample customer?
A:
Sure! Here’s the Turtle syntax with :Order instances for each sample customer:

## Turtle Start ##
@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

:Customer1 a :Customer ;
    rdfs:label "Alice" ;
    :email "alice@example.com" ;
    :phone "555-123-4567" ;
    :has :DeliveryAddress1 ;
    :places :Order1 .
:Customer2 a :Customer ;
    rdfs:label "Bob" ;
    :email "bob@example.com" ;
    :phone "555-987-6543" ;
    :has :DeliveryAddress2 ;
    :places :Order2 .
:Customer3 a :Customer ;
    rdfs:label "Charlie" ;
    :email "charlie@example.com" ;
    :phone "555-246-8101" ;
    :has :DeliveryAddress3 ;
    :places :Order3 .
:Order1 a :Order ;
    rdfs:label "Order 1" ;
    :includes :OrderItem1 ;
    :receives :DeliveryAddress1 .
:Order2 a :Order ;
    rdfs:label "Order 2" ;
    :includes :OrderItem2 ;
    :receives :DeliveryAddress2 .
:Order3 a :Order ;
    rdfs:label "Order 3" ;
    :includes :OrderItem3 ;
    :receives :DeliveryAddress3 .
:OrderItem1 a :OrderItem ;
    rdfs:label "Order Item 1" ;
    :orderedIn :Product1 ;
    :quantity 1 .
:OrderItem2 a :OrderItem ;
    rdfs:label "Order Item 2" ;
    :orderedIn :Product2 ;
    :quantity 1 .
:OrderItem3 a :OrderItem ;
    rdfs:label "Order Item 3" ;
    :orderedIn :Product3 ;
    :quantity 1 .
## Turtle End ##

In this example, I have created three instances of the :Order class and assigned them to the sample customers using the :places property. Each order includes one :OrderItem instance that corresponds to a sample product. The :receives property links the orders to the delivery addresses.

Q: Can you generate an invoice for each sample order?
A:
Certainly! Here’s the Turtle syntax with :Invoice instances for each sample order:

## Turtle Start ##
@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

:Customer1 a :Customer ;
    rdfs:label "Alice" ;
    :email "alice@example.com" ;
    :phone "555-123-4567" ;
    :has :DeliveryAddress1 ;
    :places :Order1 ;
    :liableFor :Invoice1 .
:Customer2 a :Customer ;
    rdfs:label "Bob" ;
    :email "bob@example.com" ;
    :phone "555-987-6543" ;
    :has :DeliveryAddress2 ;
    :places :Order2 ;
    :liableFor :Invoice2 .
:Customer3 a :Customer ;
    rdfs:label "Charlie" ;
    :email "charlie@example.com" ;
    :phone "555-246-8101" ;
    :has :DeliveryAddress3 ;
    :places :Order3 ;
    :liableFor :Invoice3 .
:Invoice1 a :Invoice ;
    rdfs:label "Invoice 1" ;
    :covers :Order1 ;
    :totalAmount 1200 .
:Invoice2 a :Invoice ;
    rdfs:label "Invoice 2" ;
    :covers :Order2 ;
    :totalAmount 800 .
:Invoice3 a :Invoice ;
    rdfs:label "Invoice 3" ;
    :covers :Order3 ;
    :totalAmount 15 .
## Turtle End ##

In this example, I have created three instances of the :Invoice class and assigned them to the sample customers using the :liableFor property. Each invoice covers one of the sample orders, linked with the :covers property, and has a total amount based on the price of the products in the orders.

Q: Enhance the generated ontology by adding owl:equivalentProperty and owl:equivalentClass triples cross-referencing schema.org terms, where appropriate.
A:
Certainly! Here’s the Turtle syntax with owl:equivalentProperty and owl:equivalentClass triples cross-referencing relevant schema.org terms:

@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix schema: <http://schema.org/> .

:Customer a owl:Class ;
    owl:equivalentClass schema:Person .
:DeliveryAddress a owl:Class ;
    owl:equivalentClass schema:PostalAddress .
:Order a owl:Class ;
    owl:equivalentClass schema:Order .
:Invoice a owl:Class ;
    owl:equivalentClass schema:Invoice .
:Product a owl:Class ;
    owl:equivalentClass schema:Product .
:ProductCategory a owl:Class ;
    owl:equivalentClass schema:CategoryCode .
:OrderItem a owl:Class ;
    owl:equivalentClass schema:OrderItem .
:has a owl:ObjectProperty ;
    owl:equivalentProperty schema:address .
:places a owl:ObjectProperty ;
    owl:equivalentProperty schema:orderedItem .
:liableFor a owl:ObjectProperty ;
    owl:equivalentProperty schema:billingAddress .
:receives a owl:ObjectProperty ;
    owl:equivalentProperty schema:deliveryAddress .
:covers a owl:ObjectProperty ;
    owl:equivalentProperty schema:referencesOrder .
:includes a owl:ObjectProperty ;
    owl:equivalentProperty schema:itemOffered .
:category a owl:ObjectProperty ;
    owl:equivalentProperty schema:category .
:orderedIn a owl:ObjectProperty ;
    owl:equivalentProperty schema:orderedItem .
:price a owl:DatatypeProperty ;
    owl:equivalentProperty schema:price .
:email a owl:DatatypeProperty ;
    owl:equivalentProperty schema:email .
:phone a owl:DatatypeProperty ;
    owl:equivalentProperty schema:telephone .
:street a owl:DatatypeProperty ;
    owl:equivalentProperty schema:streetAddress .
:city a owl:DatatypeProperty ;
    owl:equivalentProperty schema:addressLocality .
:state a owl:DatatypeProperty ;
    owl:equivalentProperty schema:addressRegion .
:postalCode a owl:DatatypeProperty ;
    owl:equivalentProperty schema:postalCode .
:quantity a owl:DatatypeProperty ;
    owl:equivalentProperty schema:orderQuantity .
:totalAmount a owl:DatatypeProperty ;
    owl:equivalentProperty schema:totalPaymentDue .

In this example, I have added owl:equivalentClass and owl:equivalentProperty triples to map the terms from the original ontology to corresponding schema.org terms, where applicable. This allows for better interoperability between different data sources using schema.org vocabulary.

Q: Are you sure that a Customer Class is equivalent to schema:Person?
A:
You are correct; my previous response was too general by suggesting that the :Customer class is equivalent to schema:Person. In fact, schema:Person is a more general class, while :Customer is a specific type of person in the context of this ontology. A better choice would be to use rdfs:subClassOf to indicate that :Customer is a subclass of schema:Person. Here’s the corrected Turtle syntax:

@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix schema: <http://schema.org/> .

:Customer a owl:Class ;
    rdfs:subClassOf schema:Person .
:DeliveryAddress a owl:Class ;
    owl:equivalentClass schema:PostalAddress .
:Order a owl:Class ;
    owl:equivalentClass schema:Order .
:Invoice a owl:Class ;
    owl:equivalentClass schema:Invoice .
:Product a owl:Class ;
    owl:equivalentClass schema:Product .
:ProductCategory a owl:Class ;
    owl:equivalentClass schema:CategoryCode .
:OrderItem a owl:Class ;
    owl:equivalentClass schema:OrderItem .
:has a owl:ObjectProperty ;
    owl:equivalentProperty schema:address .
:places a owl:ObjectProperty ;
    owl:equivalentProperty schema:orderedItem .
:liableFor a owl:ObjectProperty ;
    owl:equivalentProperty schema:billingAddress .
:receives a owl:ObjectProperty ;
    owl:equivalentProperty schema:deliveryAddress .
:covers a owl:ObjectProperty ;
    owl:equivalentProperty schema:referencesOrder .
:includes a owl:ObjectProperty ;
    owl:equivalentProperty schema:itemOffered .
:category a owl:ObjectProperty ;
    owl:equivalentProperty schema:category .
:orderedIn a owl:ObjectProperty ;
    owl:equivalentProperty schema:orderedItem .
:price a owl:DatatypeProperty ;
    owl:equivalentProperty schema:price .
:email a owl:DatatypeProperty ;
    owl:equivalentProperty schema:email .
:phone a owl:DatatypeProperty ;
    owl:equivalentProperty schema:telephone .
:street a owl:DatatypeProperty ;
    owl:equivalentProperty schema:streetAddress .
:city a owl:DatatypeProperty ;
    owl:equivalentProperty schema:addressLocality .
:state a owl:DatatypeProperty ;
    owl:equivalentProperty schema:addressRegion .
:postalCode a owl:DatatypeProperty ;
    owl:equivalentProperty schema:postalCode .
:quantity a owl:DatatypeProperty ;
    owl:equivalentProperty schema:orderQuantity .
:totalAmount a owl:DatatypeProperty ;
    owl:equivalentProperty schema:totalPaymentDue .

This updated Turtle syntax now correctly represents the :Customer class as a subclass of schema:Person.

Q: If :Customer Class is a subclassOf schema:Person, how do we handle organizations who are the more typical targets of an invoice?
A:
You’re right. In many cases, invoices are issued to organizations rather than individual customers. To accommodate both individual customers and organizations, we can create separate subclasses for individuals and organizations under the :Customer class. Then, we can make the :Customer class a subclass of both schema:Person and schema:Organization. Here’s the updated Turtle syntax:

@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix schema: <http://schema.org/> .

:Customer a owl:Class ;
    rdfs:subClassOf schema:Person, schema:Organization .
:IndividualCustomer a owl:Class ;
    rdfs:subClassOf :Customer ;
    rdfs:subClassOf schema:Person .
:OrganizationCustomer a owl:Class ;
    rdfs:subClassOf :Customer ;
    rdfs:subClassOf schema:

Q: Shouldn’t that be inverted?
A:
You are correct. My previous response was inaccurate. To better model this situation, we should create a :Customer class that is a superclass of both schema:Person and schema:Organization. Then, we can create separate subclasses for individuals and organizations under the :Customer class. Here’s the corrected Turtle syntax:

@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix schema: <http://schema.org/> .

:Customer a owl:Class .
:IndividualCustomer a owl:Class ;
    rdfs:subClassOf :Customer, schema:Person .
:OrganizationCustomer a owl:Class ;
    rdfs:subClassOf :Customer, schema:Organization .

This updated Turtle syntax now correctly represents the :Customer class as a superclass of both schema:Person and schema:Organization. The :IndividualCustomer class is a subclass of both :Customer and schema:Person, while the :OrganizationCustomer class is a subclass of both :Customer and schema:Organization.

Q: How about simply making schema:Organization the :Customer subclass since this ontology is business centric?
A:
Sure, that’s a valid approach if you want to focus on business-centric use cases where customers are primarily organizations. In this case, we can make :Customer a subclass of schema:Organization. Here’s the updated Turtle syntax:

@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix schema: <http://schema.org/> .

:Customer a owl:Class ;
    rdfs:subClassOf schema:Organization .

Now, the :Customer class is a subclass of schema:Organization, which means customers in this ontology are primarily organizations.

Q: Okay, regenerate the entire ontology with these corrections.
A:
Here’s the complete ontology with the requested corrections, where :Customer is a subclass of schema:Organization:

## Turtle Start ##
@prefix : <#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix schema: <http://schema.org/> .

:Customer a owl:Class ;
    rdfs:subClassOf schema:Organization .
:DeliveryAddress a owl:Class ;
    owl:equivalentClass schema:PostalAddress .
:Order a owl:Class ;
    owl:equivalentClass schema:Order .
:Invoice a owl:Class ;
    owl:equivalentClass schema:Invoice .
:Product a owl:Class ;
    owl:equivalentClass schema:Product .
:ProductCategory a owl:Class ;
    owl:equivalentClass schema:CategoryCode .
:OrderItem a owl:Class ;
    owl:equivalentClass schema:OrderItem .
:has a owl:ObjectProperty ;
    owl:equivalentProperty schema:address .
:places a owl:ObjectProperty ;
    owl:equivalentProperty schema:orderedItem .
:liableFor a owl:ObjectProperty ;
    owl:equivalentProperty schema:billingAddress .
:receives a owl:ObjectProperty ;
    owl:equivalentProperty schema:deliveryAddress .
:covers a owl:ObjectProperty ;
    owl:equivalentProperty schema:referencesOrder .
:includes a owl:ObjectProperty ;
    owl:equivalentProperty schema:itemOffered .
:category a owl:ObjectProperty ;
    owl:equivalentProperty schema:category .
:orderedIn a owl:ObjectProperty ;
    owl:equivalentProperty schema:orderedItem .
:price a owl:DatatypeProperty ;
    owl:equivalentProperty schema:price .
:email a owl:DatatypeProperty ;
    owl:equivalentProperty schema:email .
:phone a owl:DatatypeProperty ;
    owl:equivalentProperty schema:telephone .
:street a owl:DatatypeProperty ;
    owl:equivalentProperty schema:streetAddress .
:city a owl:DatatypeProperty ;
    owl:equivalentProperty schema:addressLocality .
:state a owl:DatatypeProperty ;
    owl:equivalentProperty schema:addressRegion .
:postalCode a owl:DatatypeProperty ;
    owl:equivalentProperty schema:postalCode .
:quantity a owl:DatatypeProperty ;
    owl:equivalentProperty schema:orderQuantity .
:totalAmount a owl:DatatypeProperty ;
    owl:equivalentProperty schema:totalPaymentDue .
## Turtle End ##

This ontology now has :Customer as a subclass of schema:Organization, making it more business-centric. The other classes, properties, and equivalent mappings to schema.org terms remain unchanged.

Knowledge Graph Visualization & Export Using Nanotation

At this juncture, courtesy of the ## Turtle Start ## and ## Turtle End ## comments placed around the RDF-Turtle statements generated by CHAT-GPT, simply invoke OSDS (by clicking on the “doggie” icon) to see a visualization of the graph represented in the text of this post.

In addition, the data expressed in the graph can also be uploaded directly to an Knowledge Graph or DBMS platform that supports SPARQL INSERTs e.g., the live Virtuoso instance behind our URIBurner Service. You simply select the “Upload to SPARQL Endpoint” option from the download option drop-down associated with the download action (depicted by the cloud+download arrow).

Once the data is uploaded it lays the foundation for the next stage which focuses on applying SPARQL Queries to the data that leverage reasoning and inference.

Reasoning & Inference

At this juncture, there’s a working Entity Relationship Graph that’s been constructed using Linked Data principles whereby entities, entity types, and entity relationship types are denoted using hyperlinks and described using entity->attribute-value or subject->predicate->object triples. Fundamentally, this is a Knowledge Graph about Products, Customers, Orders etc., defined by classes and properties described in an Ontology that ultimately manifests a Semantic Web.

As a Semantic Web, the meaning (or semantics) of relationship types are both human- and machine-computable which can be demonstrated by adding a few more relationships to the Ontology that cross-reference classes described by the Schema.org vocabulary.

-- a SPASQL (SPARQL integrated into SPARQL) snippet that added owl:equivalentClass relationship types to the Ontology.
-- <urn:rdfs:subclas
s:subproperty:mappings> denotes the Named Graph associated an existing Built-In Inference Rule denoted by <urn:rdfs:subclass:subproperty:inference:rules>
SPARQL
PREFIX : <https://kingsley.idehen.net/DAV/home/kidehen/Public/Linked%20Data%20Documents/Playground/gptChat/nanotations/gpt4-related/ontology-and-instance-data-example1.txt#> 
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 
PREFIX owl: <http://www.w3.org/2002/07/owl#> 
PREFIX schema: <http://schema.org/> 
WITH <urn:rdfs:subclass:subproperty:mappings>
INSERT {
:Customer a owl:Class ;
    rdfs:subClassOf schema:Organization .
:DeliveryAddress a owl:Class ;
    owl:equivalentClass schema:PostalAddress .
:Order a owl:Class ;
    owl:equivalentClass schema:Order .
:Invoice a owl:Class ;
    owl:equivalentClass schema:Invoice .
:Product a owl:Class ;
    owl:equivalentClass schema:Product .
:ProductCategory a owl:Class ;
    owl:equivalentClass schema:CategoryCode .
:OrderItem a owl:Class ;
    owl:equivalentClass schema:OrderItem .
:has a owl:ObjectProperty ;
    owl:equivalentProperty schema:address .
:places a owl:ObjectProperty ;
    owl:equivalentProperty schema:orderedItem .
:liableFor a owl:ObjectProperty ;
    owl:equivalentProperty schema:billingAddress .
:receives a owl:ObjectProperty ;
    owl:equivalentProperty schema:deliveryAddress .
:covers a owl:ObjectProperty ;
    owl:equivalentProperty schema:referencesOrder .
:includes a owl:ObjectProperty ;
    owl:equivalentProperty schema:itemOffered .
:category a owl:ObjectProperty ;
    owl:equivalentProperty schema:category .
:orderedIn a owl:ObjectProperty ;
    owl:equivalentProperty schema:orderedItem .
:price a owl:DatatypeProperty ;
    owl:equivalentProperty schema:price .
:email a owl:DatatypeProperty ;
    owl:equivalentProperty schema:email .
:phone a owl:DatatypeProperty ;
    owl:equivalentProperty schema:telephone .
:street a owl:DatatypeProperty ;
    owl:equivalentProperty schema:streetAddress .
:city a owl:DatatypeProperty ;
    owl:equivalentProperty schema:addressLocality .
:state a owl:DatatypeProperty ;
    owl:equivalentProperty schema:addressRegion .
:postalCode a owl:DatatypeProperty ;
    owl:equivalentProperty schema:postalCode .
:quantity a owl:DatatypeProperty ;
    owl:equivalentProperty schema:orderQuantity .
:totalAmount a owl:DatatypeProperty ;
    owl:equivalentProperty schema:totalPaymentDue .
} ;
-- refreshes existing rule with newly added data
RDFS_RULE_SET ('urn:rdfs:subclass:subproperty:inference:rules', 'urn:rdfs:subclass:subproperty:mappings')

SPARQL Queries with Inference Context Enabled

These queries showcasing reasoning & inference informed by Ontology can be executed against the live Virtuoso instance behind the URIBurner Query Services Endpoint at: https://linkeddata.uriburner.com/sparql

Orders Sample

DEFINE input:inference "urn:rdfs:subclass:subproperty:inference:rules"
SELECT (SAMPLE(?s) AS ?EntityID) 
       (COUNT(*) AS ?count) 
       (?o AS ?EntityTypeID) 
FROM <https://kingsley.idehen.net/DAV/home/kidehen/Public/Linked%20Data%20Documents/Playground/gptChat/nanotations/gpt4-related/ontology-and-instance-data-example1.txt#osds> 
WHERE { 
        ?s a ?o
        FILTER ( ?o = schema:Order)
} 
GROUP BY ?o 
ORDER BY DESC (?count)

Live Query Results Page Link.

Orders Dump

DEFINE input:inference "urn:rdfs:subclass:subproperty:inference:rules"

SELECT *
FROM <https://kingsley.idehen.net/DAV/home/kidehen/Public/Linked%20Data%20Documents/Playground/gptChat/nanotations/gpt4-related/ontology-and-instance-data-example1.txt#osds> 
WHERE { 
        ?s a schema:Order .
      }

Live Query Results Page Link.

Products Dump

DEFINE input:inference "urn:rdfs:subclass:subproperty:inference:rules"

SELECT *
FROM <https://kingsley.idehen.net/DAV/home/kidehen/Public/Linked%20Data%20Documents/Playground/gptChat/nanotations/gpt4-related/ontology-and-instance-data-example1.txt#osds> 
WHERE { 
        ?s a schema:Product .
      }

Live Query Results Page Link.

Organizations Dump

DEFINE input:inference "urn:rdfs:subclass:subproperty:inference:rules"

SELECT *
FROM <https://kingsley.idehen.net/DAV/home/kidehen/Public/Linked%20Data%20Documents/Playground/gptChat/nanotations/gpt4-related/ontology-and-instance-data-example1.txt#osds> 
WHERE { 
        ?s a schema:Organization .
      }

Live Query Results Page Link.

Invoices Dump

DEFINE input:inference "urn:rdfs:subclass:subproperty:inference:rules"

SELECT *
FROM <https://kingsley.idehen.net/DAV/home/kidehen/Public/Linked%20Data%20Documents/Playground/gptChat/nanotations/gpt4-related/ontology-and-instance-data-example1.txt#osds> 
WHERE { 
        ?s a schema:Invoice .
      }

Live Query Results Page Link.

Postal Addresses Dump

DEFINE input:inference "urn:rdfs:subclass:subproperty:inference:rules"

SELECT *
FROM <https://kingsley.idehen.net/DAV/home/kidehen/Public/Linked%20Data%20Documents/Playground/gptChat/nanotations/gpt4-related/ontology-and-instance-data-example1.txt#osds> 
WHERE { 
        ?s a schema:PostalAddress .
      }

Live Query Results Page Link.

When clicking on a hyperlink, courtesy of Linked Data Principles, your browser will resolve to an detailed Entity Description Page that also comprises inverse links (a/k/a backlinks) that are automatically generated by the Virtuoso’s native faceted search and browsing engine.

Related

• Mermaid Entity Relationship Model
• Additional CHAT-GPT4 Exercise Session Transcripts — these are also marked-up using Nanotation
• ChatGPT Exercises — Generating a Course Description Knowledge Graph using RDF | by Kingsley Uyi Idehen | OpenLink Software Blog | Feb, 2023 | Medium

OpenLink Data Sniffer (OSDS) Browser Extension Links

• Google Chrome Store for Chromium-based Browsers
• Mozilla Store for Firefox
• Mac App Store for Safari
• Github Open Source Repository

Additional Information

• Virtuoso Home Page

HowTo — Using CHAT-GPT to generate a Knowledge Graph from a Mermaid Entity Relationship Model was originally published in OpenLink Software Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

This guide outlines steps required for generating a Link-In-Bio variant of a Personal Profile Document, comprising public credentials that ultimately aid user-controlled self-sovereign identity.

Completing the process below will put you in position to use the YouID Credential Generator, either the browser extension or the iOS app, to achieve the following goals:

1. Generate a Link-In-Bio-style Personal Profile Document.
2. Use credentials in the Profile Document to respond to Identity Authentication challenges when trying to access protected resources from your desktop, notebook, or mobile computing device via HTTPS.

Step-by-Step Guide

Generate a Profile Document

[1] Create a folder, like https://kingsley.idehen.net/DAV/home/kidehen/Public/YouID/public-credentials-link-in-bio/

[2] Assume your PdP is going to be https://kingsley.idehen.net/DAV/home/kidehen/Public/YouID/public-credentials-link-in-bio/index.html

[3] Provide the PdP URL to YouID

[4] Complete the rest of the form

[5] Generate your Credentials

[6] Download Zip Archive

Generated Credentials Publication

[1] Unzip Archive

[2] Mount a designated remote HTTP+WebDAV accessible folder to your desktop OS i.e., the same folder created in step 1 of the Credentials Generation Section

[3] Copy all the files extracted from the ZIP archive to the WebDAV folder mounted in the previous step

[4] Use your browser to view the files in the remote WebDAV location

[5] Verify that your newly generated NetID resolves, by clicking your variant of https://kingsley.idehen.net/DAV/home/kidehen/Public/YouID/public-credentials-link-in-bio/index.html#netid

Registering a NetID with YouID’s browser-hosted credential store (also referred to as a wallet)

Note: The following steps only apply to the YouID Browser Extension (not to the YouID hosted service).

[1] Add your variant of https://kingsley.idehen.net/DAV/home/kidehen/Public/YouID/public-credentials-link-in-bio/index.html#netid to your YouID-managed NetID List.

Private Credentials Storage

[1] Locate the private credentials from the secure PKCS#12 file (situated in the folder created when you unzipped the YouID generated ZIP archive)

[2] Open the secure PKCS#12 credentials file using the mechanism provided by your host operating system (commonly a double-click, since every modern operating system understands this secure file format)

[3] If you plan to send self-signed emails using Apple Mail or Microsoft OutLook, repeat these steps for the Certificate Authority (CA) secure PKCS#12. If you plan to use Thunderbird, you will only need to load the CA’s .pem file when prompted during the configuration process for your email account.

Credentials Verification

This is achieved by a NetID-TLS verification service (at an endpoint), that implements Client Certificate Authentication using an extended session initialization handshake along the following lines:

[1] De-references the hyperlink used to denote the subject of the X.509 certificate used in the session initialization to a publicly-accessible profile document comprising a public credentials mirror, i.e., a Public Key, Public Key SHA-1 hash, etc.

[2] Compares the public and private credentials to ensure a match

[3] Returns a publicly-accessible signed certification document, if the credentials match

Screencast Demonstration

Conclusion

As demonstrated in this post, each YouID release reduces friction associated with Self-Sovereign Identity that’s fully controlled by end-users rather than technology vendors.

End-users can now take advantage of the following without any third-party dependencies:

1. Issue X.509 Certificates that can be used to digitally sign and/or encrypt emails using the S/MIME protocol — which is supported by all modern email applications across desktops, notebooks, or mobile phones
2. Generate Link In Bio profile documents comprising verifiable credentials that manifest a powerful Personal Profile Knowledge Graph, without any limitations applied to additional profile document cross-references

Availability

• …for Chrome, Brave, Opera, and other compatible browsers
• …for Firefox
• …for Safari
• …for iOS on iPhone or iPad

Related

• YouID 1.6.9 Release Notes
• YouID 1.6.4 Release Notes
• YouID & Self-Sovereign Identity using Decentralized Public Key Infrastructure (DPKI)

How-To Guide— Self-Sovereign Identity using NetID-TLS via a YouID-Generated Profile Document was originally published in OpenLink Software Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Identity authenticity is a big problem that afflicts 5.32 Billion+ users across the Internet and Web. Despite its magnitude, visibility, and scope, end-user–controlled solutions remain mercurial. Addressing this problem requires a user-controlled identity authenticity solution that operates on the following premise:

By its nature, self-sovereign identity (SSI), a critical basis for privacy, cannot be offered to an individual by third-party services. At best, a piece of software can generate credentials that contribute a piece of a puzzle that’s ultimately solved using logic expressed semantics of entity relationship types.

Building from there, the rest of this post focuses on solving the puzzle at hand using existing open standards, via the following components:

1. An X.509 certificate comprising self-signed credentials paired with a private key, where the subject is denoted using a hyperlink
2. An HTML-based profile document comprising public credentials that reconcile back to that X.509 certificate (component 1)
3. An HTTPS server that supports Client Certificate Authentication (CCA) using an extended TLS-handshake for reconciling credentials between a local X.509 certificate (component 1) and a public HTML-based profile document (component 2)

Generating Credentials

Every modern operating system includes a utility for generating X.509 digital certificates, with the OpenSSL utility as the ultimate fallback. Unfortunately, these utilities aren’t end-user–centric, making them one of the many hurdles perpetuating the challenge of user-controlled SSI. Thus, I will be choosing the end-user — oriented YouID Credentials Generator from OpenLink Software as my tool for completing this exercise, via the following steps:

[1] Install the YouID browser extension or iOS app

[2] Initialize the installed YouID by clicking on the extension or app icon

[3] Fill in the credential generation form, paying special attention to these two fields:

• Profile Document URL which holds a hyperlink value that denotes the Profile Document (component 2, above) to be paired with the X.509 Certificate (component 1, above) to be generated
• NetID which holds a hyperlink value constructed from that which denotes the Profile Document plus a #netid fragment identifier (also called an indexical)

[4] Provide a password to be used when packaging the secure credentials

[5] Click to generate the following:

• Secure PKCS#12-based local credentials file
• ZIP archive comprising public credentials
• Extracts of Public Credentials, useful for pasting into alternative profile documents (e.g., Mastodon or Twitter profile pages)

Local Credentials

Local credentials comprise an X.509 certificate and associated Private Key packaged in a secure PKCS#12 file recognized by all modern operating systems. Once this file is opened, the native operating system takes over extraction of credentials, en route to native persistent storage (such as Keychain on macOS or Key Store on Windows).

Once persistently stored, the native UI/UX provided by the host operating system handles credential interactions, such as viewing for management purposes, or accessing in response to authentication challenges when establishing HTTPS (TLS) sessions.

An X.509 Certificate viewed via Keychain

Note the use of the Subject Alternate Name (SAN) Extensions field to store the hyperlink that denotes the certificate’s subject.

Public Credentials

The ZIP archive produced by YouID contains an HTML-based profile document that includes a structured data island comprising credentials (e.g., Public Key and Fingerprints) that mirror what’s in a private X.509 certificate to which it has been paired.

• Live Demo Link

The HTML-based profile document, PKCS#12 credential bundle (including credentials for self-signed CA functionality), and other artifacts, can be extracted locally and copied to the remote folder corresponding to the hyperlink that denotes the identity principal’s HTML-based profile document.

• Live Demo Link

Verification of Credentials

The process of identity authentication using DPKI (Decentralized PKI) works as follows:

1. A user-agent attempts to access a protected resource on a remote server using the HTTPS protocol
2. The remote server issues an authentication challenge
3. The user-agent presents required local credentials for use in a session initialization handshake (which ultimately includes Private Key signing)
4. Following the conventional handshake, a NetID-TLS based server performs an additional step whereby private and public credentials are reconciled by de-referencing a hyperlink used to denote the subject of the certificate successfully used in the conventional handshake via its use as the value of the certificate’s Subject Alternative Name
5. If credentials (e.g, the Public Key and/or Fingerprint) match, the session initialization handshake is completed successfully and the resource is accessed; otherwise, the resource access attempt is rejected

Successful Credentials Matching Test Example

• Live Demo Link

Related

• YouID 1.6.4 Release Notes
• YouID Browser Extension for Google Chrome, Microsoft Edge, and other Chromium-based Browsers
• YouID Browser Extension for Mozilla Firefox
• YouID Browser Extension for Apple Safari

YouID & Self-Sovereign Identity using Decentralized Public Key Infrastructure (DPKI) was originally published in OpenLink Software Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

I stumbled upon a post by Harald Sack about his upcoming Knowledge Graph course. Naturally, this presented an opportunity to test the RDF generating capabilities of ChatGPT.

What follows is a ChatGPT session dump, best viewed using the OpenLink Structured Data Sniffer (OSDS) Browser Extension[1][2][3], that produces Knowledge Graphs generated using both RDF-Turtle and JSON-LD notations from course description text yanked out of a webpage.

Prompt

Generate an RDF rendition of the following using Turtle Notation, terms from Schema.org, and hash-based relative hyperlinks for subject and object denotation. Use a single code-block for response output.

Knowledge Graphs — Foundations and Applications

Prof. Dr. Harald Sack

Introduction

Even though it affects our lives every single day, most of us have no idea what a knowledge graph is. Asking Alexa about the weather tomorrow or searching for the latest news on climate change via Google, knowledge graphs constitute the backbone of today’s state-of-the-art information systems. From improving search results over question answering and recommender systems up to explainable AI systems, the applications of knowledge graphs are manyfold. Overall, the goal of this course is to provide a broad overview of knowledge graphs and their underlying technologies as well as their significance in today’s digital world.

October 11, 2023 — November 21, 2023
Language: English
Big Data and AI, Expert

Course information

A knowledge graph is a structured representation of knowledge that is used to provide a comprehensive and interconnected view of a specific domain. In this course we will discuss the key features and characteristics of knowledge graphs. You will learn all what is necessary to design, implement, and apply knowledge graphs. The focus of this course will be on basic semantic technologies including the underlying principles of knowledge representation and symbolic AI. This includes information encoding via RDF triples, knowledge representation via ontologies with OWL, efficiently querying knowledge graphs via SPARQL, latent representation of knowledge in vector spaces, as well as knowledge graph applications in innovative information systems, as e.g., semantic and exploratory search. Furthermore the role of knowledge graphs in artificial intelligence and machine learning will be discussed, as well as their potential to improve explainability and trustworthiness of “black box” deep learning models.

What you’ll learn

Basic understanding of knowledge graphs

Basic understanding of ontologies

Basic understanding of Semantic Web Technologies

Who this course is for

students

practitioners of computer science, digital humanities, and information sciences

enthusiasts with an AI related background and an interest in symbolic knowledge representation

Response

## Turtle Start ##
@prefix schema: <https://schema.org/> .
@prefix kg: <#> .

kg:KnowledgeGraph a schema:Course ;
  schema:name "Knowledge Graphs - Foundations and Applications" ;
  schema:about "A knowledge graph is a structured representation of knowledge that is used to provide a comprehensive and interconnected view of a specific domain. In this course we will discuss the key features and characteristics of knowledge graphs. You will learn all what is necessary to design, implement, and apply knowledge graphs. The focus of this course will be on basic semantic technologies including the underlying principles of knowledge representation and symbolic AI. This includes information encoding via RDF triples, knowledge representation via ontologies with OWL, efficiently querying knowledge graphs via SPARQL, latent representation of knowledge in vector spaces, as well as knowledge graph applications in innovative information systems, as e.g., semantic and exploratory search. Furthermore the role of knowledge graphs in artificial intelligence and machine learning will be discussed, as well as their potential to improve explainability and trustworthiness of black box deep learning models." ;
  schema:inLanguage "English" ;
  schema:startDate "2023-10-11" ;
  schema:endDate "2023-11-21" ;
  schema:educationalLevel "Expert" ;
  schema:knowsAbout [
    schema:name "Ontologies"
  ], [
    schema:name "Semantic Web Technologies"
  ], [
    schema:name "Knowledge Representation"
  ] ;
  schema:teaches [
    schema:name "Basic understanding of knowledge graphs"
  ], [
    schema:name "Basic understanding of ontologies"
  ], [
    schema:name "Basic understanding of Semantic Web Technologies"
  ] ;
  schema:audience [
    schema:name "students"
  ], [
    schema:name "practitioners of computer science, digital humanities, and information sciences"
  ], [
    schema:name "enthusiasts with an AI related background and an interest in symbolic knowledge representation"
  ] .

## Turtle End ##

## JSON-LD Start ##
{
  "@context": "https://schema.org/",
  "@type": "Course",
  "name": "Knowledge Graphs - Foundations and Applications",
  "about": "A knowledge graph is a structured representation of knowledge that is used to provide a comprehensive and interconnected view of a specific domain. In this course we will discuss the key features and characteristics of knowledge graphs. You will learn all what is necessary to design, implement, and apply knowledge graphs. The focus of this course will be on basic semantic technologies including the underlying principles of knowledge representation and symbolic AI. This includes information encoding via RDF triples, knowledge representation via ontologies with OWL, efficiently querying knowledge graphs via SPARQL, latent representation of knowledge in vector spaces, as well as knowledge graph applications in innovative information systems, as e.g., semantic and exploratory search. Furthermore the role of knowledge graphs in artificial intelligence and machine learning will be discussed, as well as their potential to improve explainability and trustworthiness of black box deep learning models.",
  "inLanguage": "English",
  "startDate": "2023-10-11",
  "endDate": "2023-11-21",
  "educationalLevel": "Expert",
  "knowsAbout": [
    {
      "@type": "Text",
      "name": "Ontologies"
    },
    {
      "@type": "Text",
      "name": "Semantic Web Technologies"
    },
    {
      "@type": "Text",
      "name": "Knowledge Representation"
    }
  ],
  "teaches": [
    {
      "@type": "Text",
      "name": "Basic understanding of knowledge graphs"
    },
    {
      "@type": "Text",
      "name": "Basic understanding of ontologies"
    },
    {
      "@type": "Text",
      "name": "Basic understanding of Semantic Web Technologies"
    }
  ],
  "audience": [
    {
      "@type": "Text",
      "name": "students"
    },
    {
      "@type": "Text",
      "name": "practitioners of computer science, digital humanities, and information sciences"
    },
    {
      "@type": "Text",
      "name": "enthusiasts with an AI related background and an interest in symbolic knowledge representation"
    }
  ]
}

## JSON-LD End ##

Task Screenshots

ChatGPT RDF-Turtle Generation Response

ChatGPT RDF-Turtle Generation Response viewed using OSDS

ChatGPT JSON-LD Generation Response

ChatGPT JSON-LD Generation Response viewed using OSDS

Uploading Generated Knowledge Graph to a DBMS that supports SPARQL

In addition to discovering and visualizing RDF-based Knowledge Graphs embedded in webpages, OSDS also offers upload functionality to any SPARQL endpoint that supports SPARQL INSERTs.

Here’s how the ChatGPT generated knowledge graph is uploaded to the Virtuoso Instance behind our public URIBurner Service.

[1] Select RDF-Notation matching what’s generated in the ChatGPT Response Code Block e.g., RDF-Turtle and/or JSON-LD as per the example used in this post

[2] Initialize OSDS by clicking on its “doggie” icon

[3] Goto the “Download from Cloud” icon and click on it

[4] From the drop-down presented, select “Upload to SPARQL Endpoint”

[5] If you so desire, replace the default SPARQL Endpoint URL presented by replacing it with your preferred alternative

[6] If you so desire, replace the default destination Named Graph Identifier presented by replacing it with your preferred alternative

[7] Click OK to commence upload to your selected SPARQL endpoint

[8] Explore the newly created Knowledge Graph via the SPARQL Query Solution Page automatically generated by OSDS

Conclusion

As this post demonstrates, taking the tedium out of RDF generation is a productivity boosting benefit of ChatGPT that’s immediately usable as part of any Knowledge Graph familiarization and/or utilization effort.

Related Exercises

• ChatGPT Prompt Collection — from my Personal Data Space
• Other ChatGPT Prompt & Nanotations related demo exercises — from my Personal Data Space (an ODS-Briefcase Instance)
• General ChatGPT demo exercises collection — from Personal Data Space
• ChatGPT generating a Job Postings Knowledge Graph — Screencast Demo
• ChatGPT generating a HowTo Knowledge Graph — Screencast Demo

OpenLink Data Sniffer (OSDS) Browser Extension Links

• Google Chrome Store for Chromium-based Browsers
• Mozilla Store for Firefox 1
• Mac App Store for Safari 1
• Github Open Source Repository

Additional Information

• Virtuoso Home Page

Using ChatGPT to Generate a Course Description Knowledge Graph using RDF was originally published in OpenLink Software Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Situation Analysis

Once again, we are at a critical inflection point regarding use of the global communications opportunities enabled by open-standards-based infrastructure provided by the Web and Internet. The current inflection has been triggered by Twitter, the “global town square” that until recently stood without any viable alternatives — which is never a good thing.

Twitter is a Web 2.0 platform that suffers from tight-coupling of the key components that make it a centralized hub for both real-time news and digital sociality. Unfortunately, despite its quasi-monopoly status, this company never figured out how to fully maximize its unique status thereby making it a high value target for acquisition. Even worse, its recent acquisition has forced its users to revisit the importance of alternatives — even if this is a simply a case of creating a multi- rather than single-winner market situation.

Twitter Alternatives

Courtesy of existing open standards, Mastodon is emerging as a viable Twitter alternative that most would deem impossible at first blush.

Mastodon is ushering in the “third wave” of the blogosphere that first emerged circa 2000. Initially, the blogosphere comprised a federation of weblog (or blog) servers, typically self-hosted, that enabled individuals to perform the following tasks:

• Write posts
• Publish posts
• Tag posts using Hashtags
• Syndicate posts via RSS Feeds
• Comment on posts
• Subscribe to RSS Feeds
• Follow Hashtags
• Cross-reference posts
• Obtain post content in HTML or the ActivityStreams dialect of JSON (i.e., JSON-LD)

As the first wave achieved critical mass, there arose an emerging need for more spontaneous posting (a/k/a micro-blogging) and a simplified approach to blog server hosting that, like most things associated with the Web 2.0 moniker, meant a centralized alternative offered by a VC-funded startup. Ultimately, Twitter emerged as the dominant platform for micro-blogging (which became known as “tweeting”) in this new phase.

Recently, Elon Musk acquired Twitter (quite reluctantly, following initial enthusiasm) and in the process, following recent events, brought the issue of Twitter alternatives to everyone’s attention by inadvertently posing the question:

What happens if Twitter ceases to exist, or no longer offers an acceptable service?

This is where Mastodon comes into play, and based on my personal experience with the platform, I can confidently state that it actually matches and ultimately exceeds Twitter, thereby offering a genuine alternative that should also introduce much needed competition in this most important area of global communications.

What does Mastodon do so well, using existing open standards? Everything Twitter offers, plus:

• Content publication using HTML that includes embedded Knowledge Graphs that ultimately aid Search Engine understanding and serendipitous discovery
• Content syndication using RSS Feeds — enabling loosely-coupled content subscription using a variety tools
• Identity Authenticity — enabled via profile pages that comprise Verifiable Credentials or function as the foundation of explicit Self-Sovereign Identity
• Use of Hashtags as Concept Identifiers — a vector for progressive Knowledge Graph creation, enrichment, and serendipitous discovery
• Source code availability via its Open Source nature

Like Google, who empowered the miracle of Knowledge Graph publication via HTML that’s driving a new generation of content management and search engine optimization platforms, Mastodon is enabling the long-delayed third wave of the World Wide Web, comprising a “Web of Data” where every entity, entity type, and entity relationship type is named using a hyperlink.

Twitter vs Mastodon Tabulated Comparison

Mastodon Examples

To get a feel for the inflection I describe, you can click on the following links that name a few Mastodon Profile Pages:

• Jon Udell
• Mitch Kapor
• Dan Brickley
• Denny Vrandečić
• Chris Trottier
• Le Lefever
• Kingsley Uyi Idehen (moi)

Web of Data Examples

Here are some live links that demonstrate a new kind of data access and connectivity offered natively by any post on Mastodon. Basically, an HTML document functioning as the same kind of structured data source as a Table in a Database Management System (DBMS), courtesy of embedded Knowledge Graphs.

[1] GraphQL query targeting the Data Feeds Item instance Knowledge Graph embedded in Jon Udell’s profile page on Mastodon

Combined GraphQL Query and Solution Page

[2] SPARQL query targeting the Data Feeds Item instance Knowledge Graph embedded in Jon Udell’s profile page on Mastodon

SPARQL Query Solution Page

• SPARQL Query Page

[3] SQL query targeting the Data Feeds Item instance Knowledge Graph embedded in Jon Udell’s profile page on Mastodon

Combined SQL Query and Solution Page

Conclusion

The HTTP protocol unveiled a power tool for creating hyperlinks that leveraged underlying Internet infrastructure. The first piece of magic that came out of that was a global document network (i.e., World Wide Web) where every HTML page was named using a hyperlink. Unfortunately, the global success of that wonderful piece of technical work inadvertently obscured a much bigger and more powerful output — a global Knowledge Graph (or Web of Machine Computable Data) where every entity, entity relationship type, and entity type is named using a hyperlink.

Despite the 22+ year hike, right in the midst of all the problems that Web 2.0 platforms have unleashed on society and even democracy via their centralization of both the Web and the Internet, we have still finally arrived at a new frontier that provides a viable platform for addressing important issues such as these:

• Content Publication
• Content Syndication
• Identity Authenticity
• Privacy
• Business Model Flexibility, i.e., options beyond advertising for funding services at scale

Net result, Twitter is looking more like Windows, while Mastodon is looking more like macOS, i.e., a Unix variant without the UI/UX related challenges that have typically constrained high-level end-user adoption.

Related

• Dawn of The Fediverse
• reb00ted | Open networks are more valuable than closed ones: the case for the Fediverse over Twitter and Facebook
• The Breadth of the Fediverse | Electronic Frontier Foundation (eff.org)
• Mastodon FAQ & Explainer — by Le LeFever
• Pluralistic: Better failure for social media (19 Dec 2022) — Pluralistic: Daily links from Cory Doctorow
• Numerous social apps see gains in wake of Twitter chaos, new data shows | TechCrunch
• The Fediverse Could Be Awesome (if we don’t screw it up) | Electronic Frontier Foundation (eff.org)
• The Fediverse unlocks a world of composable distributed apps — Voices of Open Source — there’s more to Mastodon that simply replacing Twitter
• Autonomy, packet size, friction, fanout, and velocity — Jon Udell
• Twitter vs Mastodon
• How Mastodon and the Fediverse put social networks in people’s hands | PCWorld
• Twitter alternative: how Mastodon is designed to be “antiviral”
• Bye, Twitter — By Tim Bray
• Destruction of the Commons — The Cagle Report
• How to Make a Mastodon Account and Join the Fediverse | Electronic Frontier Foundation (eff.org)
• How to leave Twitter and switch to Mastodon
• Mastodon Scalability Challenges
• CNET Guide to Mastodon
• Internet Archive Article about Mastodon
• Twitter Thread about my path to Mastodon acceptance as viable Twitter alternative
• Understanding Mastodon — Twitter Thread
• Legacy Blog Post about Data Spaces
• The Inside Story Of How Social Media Rewired Our Minds And Our World

Chrome Store Listing Page

Chrome Store Listing Page.png1253×726 176 KB

This powerful browser extension provides the following benefits:

• Discovery of Knowledge Graphs embedded in Web Pages
• Unambiguous Entity Naming using Super Links
• Knowledge Graph Export and Upload to SPARQL Query Service Endpoints that support SPARQL 1.1 for Create, Read, Update, Delete (CRUD) operations
• Built-in SPARQL Query Editor
• Built-in URL Component Editor for RESTful interactions
• Knowledge Graph transformation using a variety of Structured Data Formats

OSDS Exposing Web Application Knowledge Graph from its own Chrome Store Listing Page

Availability

• Google Chrome Store for Chromium-based Browsers
• Mozilla Store for Firefox 1
• Mac App Store for Safari 1
• Github Open Source Repository

Release Notes — including updates from 2.20.30 to 2.21.6

• Added Upload to SPARQL option in Settings dialog with SPARQL Endpoint URL and Query Timeout fields
• Fixed issue with improperly rereading Nanotation data after page content is updated
• Fixed issue with RSS/Atom
• Fixed issue with parsing bad JSON data with unescaped \n, \t, \r, \f, \b
• Fixed issue with exporting from JSON-LD to N-Quads
• Added option to activate JSON-LD Compact with support for Relative IRIs
• JSON-LD JavaScript library updated to the latest version (8.1.0)
• Fixed issue with incorrect character escaping in some RDF output
• Enhanced error condition handler associated with “Upload to SPARQL Endpoint”
• N3.js library updated to the latest version (1.16.2)
• Updated character encoding used for IRI construction in HTML and RDF-Turtle generation
• Enhanced code for User Interface tabs

Related

• OpenLink Structured Data Sniffer — New Features Update | by Kingsley Uyi Idehen | OpenLink Software Blog | Medium

OpenLink Structured Data Sniffer (OSDS) version 2.21.6. was originally published in OpenLink Software Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

This new release (1.5.11) adds Bitcoin and Ethereum blockchains as additional sources of credentials for self-sovereign identity authenticity that work without incurring any “gas fees” nor triggering any “proof of work” or “proof of stake” related operations.

User Interface for generating self-sovereign identity credentials pegged to a Bitcoin Blockchain

youid-btc-blockchain-cert-demo-11130×740 49.3 KB

User Interface for generating self-sovereign identity credentials pegged to an Ethereum Blockchain

youid-eth-blockchain-cert-demo-11158×732 49 KB

What is YouID?

YouID is a tool for generating personal credentials (each comprised of a digital certificate and associated private key) that enable Internet- and Web-scale identity authenticity to be controlled by users themselves, rather than by third parties.

Why is YouID important?

Privacy and identity authenticity currently pose the biggest challenges to the deeply connected world arising from Internet and Web ubiquity. This challenge exists primarily due to the complex nature of identity, and the historic inability of technological solutions to understand the challenges posed both to the individual and to society at large.

Grounding Rule:
A third party cannot provide an individual with privacy, since that is a strictly individual superpower.

That rule provides both the technical and philosophical foundation upon which YouID has been developed.

How do I use YouID?

Simply perform the following steps:

1. Launch the browser extension or iOS app
2. Select your preferred source of profile information
3. Fill in any empty fields remaining in the credentials data entry form
4. Generate a credential document — a secure file comprising a digital identity card (a/k/a certificate) and its associated private key
5. Download the secure credential document to your desktop, notebook, tablet, or phone
6. Open the credential document on your chosen device, and let the native operating system complete the process of storing your credential safely in its native credential store (a/k/a Keychain or Key Store)

Once completed, you will be able to perform the following tasks:

• Send digitally signed emails that can be verified by the recipients email package
• Send digitally signed and encrypted emails that can be verified and decrypted by the recipients email package
• Sign PDFs (including documents sent for signature by various digital signing services)
• Begin the pursuit of document sharing (with specific individuals or groups) without requiring sharing-invitation recipients to join third party services

Related

• YouID App Store Entry — covering native iOS App, native macOS App, and macOS Safari Browser Extension
• YouID Browser Extension for Chrome, Edge, and other Chrome-based Browsers
• YouID for Firefox
• YouID Introduction Post — announcement of prior release

Introducing YouID version 1.5.11 was originally published in OpenLink Software Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.