Get AI summaries of any video or article — Sign up free
Rethinking PKM Part 4: Gardening in my Obsidian Vault with ExcaliBrain and Dataview thumbnail

Rethinking PKM Part 4: Gardening in my Obsidian Vault with ExcaliBrain and Dataview

5 min read

Based on Zsolt's Visual Personal Knowledge Management's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Encode link relationships as explicit DataView fields so Excalibrain can render consistent parent/child/friend graph layouts.

Briefing

A key shift in personal knowledge management is treating link structure as an explicit “ontology”—a defined set of relationship types—then using Excalibrain to visualize those relationships consistently inside an Obsidian vault. The payoff is practical: once relationships like “friend,” “parent,” and “child” are encoded as fields, Excalibrain can render a graph where related documents and concepts appear in predictable positions, making exploration faster and meaning clearer.

The workflow centers on separating two mental tasks that often get mixed together: (1) deciding what relationship a link represents and (2) deciding how that relationship should be visualized in Excalibrain. Instead of designing visualization on the fly, the user adds a DataView field (the “example” field in the “Building a Second Brain” page) that acts as the ontology for that link. Excalibrain then uses the field to show how “Building a Second Brain” relates to “Gardening in my world” and to other surrounding documents. Crucially, the relationship definition isn’t locked in—changing the ontology mapping later can immediately alter the graph layout. For instance, moving items from “friend” to “child” is done by editing the ontology field in Excalibrain settings, after which the graph updates so “Building a Second Brain” becomes a child of “Gardening in my world.”

To keep the system clean, the transcript describes a cleanup step for Excalibrain’s “unassigned fields” list. Many DataView fields exist in the vault but haven’t yet been categorized as parent/child/friend. Some fields are intentionally excluded from the ontology because they’re not meant to become links—examples include “twitter” (a username/address) and “email” (never a navigable node). By moving such fields into an “excluded” category, they disappear from the unassigned list and avoid cluttering the ontology choices.

The same categorization logic extends to fields that represent roles or membership. “Architect,” for example, is treated as a member of a project, so it’s added in a way that places related people on the left side of the graph when viewing project relationships. The end result is a consistent visual grammar: when someone is sought in relation to a project, the graph layout signals where that person should appear.

Excalibrain enhancements also support the workflow. A suggester lists all DataView fields that are valid ontology candidates, with triggers to filter by parent, child, friend, or the full set. DataView “mid-sentence fields” let the user embed ontology-driven links inside running text using bracket syntax, so concepts can be linked naturally within sentences.

The transcript then argues that ontology should be built while writing, not retrofitted later. A retrospective cleanup attempt is described as “super hard slash impossible,” requiring significant time and mental effort. The practical conclusion: adding ontology upfront reduces uncertainty about what to write as a connector and adds context immediately, which later enables Excalibrain graphs to reveal connections that would otherwise remain hidden.

Finally, the workflow includes quick corrections: when a new relationship like “contradicts” appears as unassigned, it can be promoted into the ontology via a comment palette action (e.g., setting it as a “friend”). A display toggle controls whether suggested field names appear in bold, improving readability when inserting DataView fields into text.

Cornell Notes

The core idea is to treat link relationships in an Obsidian vault as an explicit ontology—categorizing links as parent, child, friend (and excluding fields that should never become links). Excalibrain uses DataView fields to visualize those relationships in a consistent graph layout, and the mapping can be changed later (e.g., moving “example” items from friend to child updates the graph). A major workflow principle is separating relationship definition from visualization decisions, so the ontology is encoded as fields first. Building ontology while writing is emphasized because retroactive cleanup is described as nearly impossible; doing it upfront reduces uncertainty and adds context immediately. Excalibrain’s suggester and DataView mid-sentence fields support fast, in-text linking that stays aligned with the ontology.

What does “ontology of links” mean in this workflow, and how is it implemented in Obsidian?

Ontology here means a defined set of relationship categories (like parent/child/friend) plus how those categories relate to documents. Implementation uses DataView fields added to links. In the example page (“Building a Second Brain”), the user adds a DataView field called “example” to represent the relationship type for a specific link. Excalibrain then reads that field and renders the relationship in the graph (showing where related documents appear relative to “Gardening in my world”).

Why does separating relationship definition from visualization matter?

The transcript credits better thinking to keeping two tasks distinct: deciding what relationship a link represents (captured in an ontology field) versus deciding how Excalibrain should visualize that relationship. Because the relationship is encoded as a field, visualization can be adjusted later without rethinking every link. A concrete example is changing “Building a Second Brain” from a “friend” relationship to a “child” relationship by editing Excalibrain settings for the “example” field, which updates the graph layout.

How does the workflow prevent ontology clutter from fields that should never become graph links?

It uses an “excluded” category for DataView fields that are present in the vault but not meant to create navigable relationships. “Twitter” is treated as a username/address and “email” as a contact value—both are never intended as link nodes. By adding these field names to the excluded list, they disappear from Excalibrain’s “unassigned fields” and don’t pollute ontology suggestions.

What role do Excalibrain’s suggester and DataView mid-sentence fields play?

The suggester lists ontology-eligible DataView fields and can filter them by parent, child, friend, or all valid ontology fields via trigger combinations. DataView mid-sentence fields let the user embed ontology-driven links inside running text using bracket syntax, with different bracket options producing slightly different look-and-feel. This supports natural writing while still generating structured relationships for the graph.

Why is retroactive ontology cleanup discouraged?

The transcript describes retrospective cleanup as “super hard slash impossible” because it requires significant brain work and time to reconstruct meaningful relationship categories after the fact. The practical takeaway is to invest effort while creating notes: when ontology is clear during writing, the user knows why a link exists and what connector/context to use, adding value immediately rather than trying to fix structure later.

How are new relationship types handled when they first appear as unassigned?

When a relationship like “contradicts” is encountered, it may initially show up in the unassigned list. The workflow then promotes it into the ontology using the comment palette—choosing a relationship category such as “friend.” After that, “contradicts” appears in Excalibrain settings under the chosen category and becomes usable for consistent graph visualization.

Review Questions

  1. How does adding a DataView field to a link enable Excalibrain to render parent/child/friend relationships in the graph?
  2. What specific steps are used to move a field from “unassigned” into an ontology category, and how does excluding fields reduce clutter?
  3. Why does the transcript claim retroactive ontology cleanup is nearly infeasible, and what alternative workflow is recommended?

Key Points

  1. 1

    Encode link relationships as explicit DataView fields so Excalibrain can render consistent parent/child/friend graph layouts.

  2. 2

    Keep relationship definition separate from visualization decisions; store the relationship in an ontology field first, then adjust visualization later if needed.

  3. 3

    Use an “excluded” category for fields like “twitter” and “email” that should never become link nodes, preventing ontology clutter.

  4. 4

    Leverage Excalibrain’s suggester to insert only valid ontology fields and filter by parent/child/friend when editing.

  5. 5

    Use DataView mid-sentence fields to create structured links inside normal writing without breaking flow.

  6. 6

    Build ontology while writing; retroactive cleanup is described as extremely difficult and not worth the effort.

  7. 7

    When new relationship types appear (e.g., “contradicts”), promote them into the ontology via the comment palette to keep the system coherent.

Highlights

Ontology is implemented as DataView fields that label links, letting Excalibrain visualize relationships like parent/child/friend in a predictable graph layout.
Changing how a field is categorized (e.g., moving “example” from friend to child) can update the graph structure without rewriting every note.
Retrofitting ontology later is described as nearly impossible; doing it upfront reduces uncertainty and adds context immediately.
Fields that should never become links—such as “twitter” and “email”—are excluded to keep ontology suggestions clean.
Mid-sentence DataView fields allow ontology-driven linking inside running text, supporting both writing and structure.

Topics

  • Ontology for Links
  • Excalibrain Graphs
  • DataView Fields
  • Mid-Sentence Linking
  • Retrospective Cleanup