Working with Knowledge Graphs and Ontologies in Symbolic AI: A Practical Guide

Knowledge graphs and ontologies in Symbolic AI encode domain expertise as structured triplets and semantic relationships, enabling transparent reasoning through forward and backward inference engines.

The microsoft/AI-For-Beginners repository provides a comprehensive curriculum for classical AI techniques through its dedicated Symbolic AI module located in lessons/2-Symbolic. This educational resource teaches developers how to represent knowledge formally using the Semantic Web stack, build expert systems with production rules, and query large-scale concept graphs for real-world applications.

Knowledge Representation Fundamentals

Symbolic AI, often referred to as GOFAI (Good Old-Fashioned AI), relies on explicit symbolic representations rather than statistical learning. The curriculum structures knowledge creation around the DIKW pyramid (Data → Information → Knowledge → Wisdom), illustrating how raw observations transform into actionable expertise through systematic encoding.

Object-Attribute-Value Triplets

The core primitive throughout the course is the Object-Attribute-Value (OAV) triplet. These subject-predicate-object statements form the basis of knowledge graphs and can be serialized directly as RDF triples. As defined in lessons/2-Symbolic/README.md, a simple knowledge base about Python appears as:

# Example OAV triplet list

triplets = [
    ("Python", "is", "Untyped-Language"),
    ("Python", "invented-by", "Guido van Rossum"),
    ("Python", "block-syntax", "indentation")
]

These triplets populate the knowledge base that inference engines manipulate to derive logical conclusions.

Building Expert Systems with Inference Engines

The lessons/2-Symbolic/Animals.ipynb notebook demonstrates practical implementation of a rule-based expert system using triplet facts and production rules.

Forward and Backward Reasoning

The repository implements two classical reasoning strategies:

• Forward chaining: Data-driven inference that begins with known facts and applies rules to derive new conclusions until reaching a goal.
• Backward chaining: Goal-driven reasoning that starts with a hypothesis and works backward to locate supporting evidence in the knowledge base.

The Animals notebook encodes diagnostic rules in plain English:

IF the animal eats meat OR (has sharp teeth AND has claws AND has forward-looking eyes)
THEN the animal is a carnivore

Production Rules in Python

Here is a self-contained forward-chaining engine based on the curriculum's approach in lessons/2-Symbolic/Animals.ipynb:

# Define a tiny knowledge base as a list of OAV triplets

kb = [
    ("Tiger", "has", "stripes"),
    ("Tiger", "is", "carnivore"),
    ("Elephant", "has", "tusks"),
    ("Elephant", "is", "herbivore")
]

# Simple forward-chaining engine

def forward_chain(facts, rules):
    inferred = set(facts)
    while True:
        new = set()
        for rule in rules:
            if all(cond in inferred for cond in rule["if"]):
                new.add(rule["then"])
        if not new - inferred:
            break
        inferred |= new
    return inferred

# Example rule: if X is carnivore → X eats meat

rules = [
    {"if": [("X", "is", "carnivore")], "then": ("X", "eats", "meat")}
]

print(forward_chain(kb, rules))

Formal Ontologies and the Semantic Web

The lessons/2-Symbolic/FamilyOntology.ipynb notebook introduces the Semantic Web stack: RDF, RDFS, OWL, and Description Logics. These technologies enable formal ontology construction where classes, properties, and restrictions are explicitly defined.

RDF and OWL Implementation

This notebook demonstrates loading GEDCOM family-tree data and defining OWL classes for relationships such as parent, sibling, and cousin. Using the rdflib library, learners construct graphs and leverage transitive reasoning to infer ancestral relationships:

from rdflib import Graph, Namespace, URIRef, RDF

EX = Namespace("http://example.org/family#")
g = Graph()
g.add((EX.Alice, EX.parentOf, EX.Bob))

# Infer transitive 'ancestor' relationship

The curriculum recommends Protégé, the open-source ontology editor, for visualizing complex hierarchies before importing them into Python environments.

Querying Knowledge Graphs with SPARQL

Once ontologies are loaded as RDF graphs, you retrieve specific patterns using SPARQL queries:

from rdflib import Graph

g = Graph()
g.parse("https://raw.githubusercontent.com/microsoft/AI-For-Beginners/main/lessons/2-Symbolic/FamilyOntology.ipynb", format="json-ld")

q = """
PREFIX ex: <http://example.org/family#>
SELECT ?person ?ancestor WHERE {
  ?person ex:ancestorOf ?ancestor .
}
"""
for row in g.query(q):
    print(row.person, "is ancestor of", row.ancestor)

(Replace the URL with the actual RDF dump if needed.)

Scaling with the Microsoft Concept Graph

The lessons/2-Symbolic/MSConceptGraph.ipynb notebook bridges classical Symbolic AI and modern data-driven applications by querying the Microsoft Concept Graph—a massive taxonomy containing millions of concepts and their hierarchical relationships.

This notebook demonstrates entity-type clustering, where news articles are categorized by mapping text to high-level categories using the is-a hierarchy:

import requests

endpoint = "https://conceptgraph.microsoft.com/api/v1/entities"
params = {"term": "artificial intelligence"}
r = requests.get(endpoint, params=params)
for entity in r.json()["entities"][:5]:
    print(entity["label"], "→", entity["score"])

The Concept Graph API requires an Azure subscription key, and the notebook demonstrates secure credential management for production deployments.

Summary

• Symbolic AI represents knowledge explicitly through OAV triplets, frames, and production rules rather than learned statistical patterns, following the classic knowledge → representation → reasoning → action pipeline.
• The microsoft/AI-For-Beginners repository provides executable notebooks (Animals.ipynb, FamilyOntology.ipynb) that implement both forward and backward inference engines using pure Python.
• RDF and OWL ontologies enable formal, standardized knowledge representation with transitive reasoning capabilities, while SPARQL provides declarative graph query functionality.
• The Microsoft Concept Graph offers a practical bridge between symbolic reasoning and statistical AI through its comprehensive is-a taxonomy for entity disambiguation and text classification.

Frequently Asked Questions

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

An ontology defines the formal schema, classes, properties, and relationships for a domain—essentially the vocabulary and logical rules. A knowledge graph is the instantiated data that populates that schema with specific entities and facts. In the Family Ontology notebook, the ontology defines what "parent" means logically, while the knowledge graph contains specific triplets stating that Alice is the parent of Bob.

How does forward chaining differ from backward chaining in expert systems?

Forward chaining is data-driven: it starts with known facts in the knowledge base and applies inference rules to derive new conclusions until reaching a goal. Backward chaining is goal-driven: it starts with a hypothesis and works backward to determine if supporting facts exist in the knowledge base. The Animals.ipynb notebook implements both strategies for identifying animals based on observed characteristics.

Can Symbolic AI techniques integrate with modern machine learning models?

Yes. The Microsoft Concept Graph integration demonstrated in MSConceptGraph.ipynb shows how symbolic knowledge bases enhance statistical models by providing structured taxonomies for entity disambiguation. Modern neuro-symbolic AI architectures explicitly combine neural networks with the transparent reasoning capabilities taught in this curriculum.

What tools are required to build ontologies using this curriculum?

The repository requires Python 3 with the rdflib library for programmatic ontology construction, and recommends Protégé for visual ontology editing. All dependencies are specified in the repository's conda environment configuration, and the lessons run in standard Jupyter notebooks without additional proprietary software.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}