Get AI summaries of any video or article — Sign up free
Tana Build-Along: Build a Note-Taking System with Me thumbnail

Tana Build-Along: Build a Note-Taking System with Me

CortexFutura Tools·
5 min read

Based on CortexFutura Tools's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Build the schema around three super tags—Source, Highlight, and Fleeting Note—so every insight stays traceable to its origin.

Briefing

A practical note-taking architecture in Tana can be built from scratch by treating “sources” as the root unit of knowledge, then layering highlights, topics, concepts, and fleeting notes on top. The system’s payoff is that every quote or idea extracted from a book, video, or podcast stays traceable back to its origin, while also becoming searchable through topic and concept relationships.

The build starts with a blank workspace and creates a daily dashboard using a calendar node and a day super tag. From there, the core schema is assembled using three super tags: **Source** (the book/video/audio item being consumed), **Highlight** (the extracted text from that source), and **Fleeting Note** (the user’s immediate thoughts about a highlight). Converting normal nodes into super tags is done via a command workflow, and the resulting super tags are placed into the schema so they can share a consistent structure.

The **Source** super tag is configured with fields that make downstream retrieval easier: a **Source status** field (implemented as options like read/watch/listen) and a **topic(s)** field. To keep status visually scannable, the system uses emoji icons tied to each status option, then feeds those icons into a “build title from fields” rule so nodes display the right icon automatically. A key design choice is naming clarity: instead of a generic “status,” the field is explicitly called **Source status** to avoid confusion when other statuses (like project status) appear later.

Next comes **Topics** and **Concepts**, which turn simple tagging into a connected knowledge graph. Topics are set up as an instance field on highlights (so each highlight can be tagged with one or more topics). A live search then powers a “material” view that pulls in all sources whose topic matches a given topic node. Concepts extend topics: a **Concept** super tag adds a recursive “part of” relationship so the system can answer structural questions like “what is part of consequentialism?” using a live search that supports semantic function queries across multiple levels.

**Highlights** are configured to belong to exactly one source and to reuse the topic field. The build also adds practical metadata such as a **location** field (e.g., page numbers) and demonstrates how missing default values (like an unset Source status) can break icon rendering—solved by setting a default status (e.g., default to “to read”).

With the minimum viable system in place, the workflow expands into dashboards. A **Bookshelf** node is created with live searches for “currently reading,” “to read,” “to watch,” “to listen,” and “done,” using Source status options across multiple source types. Another daily view shows recently created fleeting notes and highlights (e.g., last 3 days), making it easy to revisit work.

Finally, the system adds AI-assisted topic extraction. An AI-enhanced field on the **topics** field reads highlight text and returns 1–3 candidate topics formatted as double-square-bracket links inside a markdown code block. Tana then links those to existing topic nodes or creates new ones, enabling one-click enrichment of the graph. The session ends by packaging the build into a shareable template, with guidance on where super tags and live searches must be nested to publish safely without exposing the primary workspace.

Cornell Notes

The build constructs a Tana note-taking system by starting with **Sources** as the root object, then extracting **Highlights** from each source, tagging them with **Topics**, organizing deeper relationships as **Concepts**, and capturing immediate reactions as **Fleeting Notes**. Source nodes track progress using a **Source status** options field (read/watch/listen) and display status via emoji icons injected into node titles. Topics and Concepts become navigable through live searches, including recursive “part of” relationships for concepts. The system then adds dashboards (Bookshelf and recent activity) and an AI-enhanced topics workflow that extracts 1–3 topics from highlight text and links them into the graph using double-square-bracket formatting.

Why does the system treat “Source” as the fundamental unit of knowledge?

Every highlight and insight is anchored to where it came from. The workflow starts by ingesting a book/video/podcast as a Source, then attaches extracted quotes (Highlights) to that Source. When deeper understanding is needed, Highlights are connected to Topics, and Topics can be extended into Concepts with relationships like “part of.” This keeps retrieval and citation-style traceability intact: when revisiting an idea, the system can show the exact originating material.

How does the build make Source status both searchable and visually obvious?

Source status is implemented as an **options** field with values such as read/watch/listen. For each option, an **icon** field stores the corresponding emoji. A “build title from fields” rule then renders the emoji in the node’s title, so status is visible at a glance. A practical detail: if Source status is unset, icons won’t appear; setting a default (e.g., default to “to read”) fixes missing icons.

What’s the difference between Topics and Concepts in this system?

Topics are the broader tags that highlights can be assigned to (e.g., “Whaling”). Concepts are a refinement: not every topic is a concept, but concepts are always topics. Concepts add structure by introducing a **part of** relationship (an instance field on concepts). Live searches using semantic functions can then resolve indirect relationships—e.g., showing concepts that appear as part-of a larger concept even when the link is multi-step.

How do live searches power navigation like “Bookshelf” and “recent notes”?

Live searches act as dynamic views. The Bookshelf uses queries that filter **sources** by **Source status** (to read/to watch/to listen/done) and can combine multiple statuses with OR logic. The daily dashboard uses live searches constrained by creation time (e.g., created in the last 3 days) to list recent fleeting notes and recent highlights, so the day view becomes a quick review surface.

How does AI topic extraction work without “searching the whole workspace”?

The AI-enhanced topics field doesn’t crawl the workspace. Instead, it generates candidate topic names from the highlight text, formatted as double-square-bracket links inside a markdown code block. Tana then checks whether nodes with those exact names already exist; if they do, it links them, and if not, it creates them. To restrict AI to only existing topics, the prompt can include a live-search-derived list of allowed topic nodes, so the AI selects only from that set.

What’s required to publish the system as a template safely?

Super tags and related live searches must be nested under the node that will be published (e.g., moving schema-contained super tags into the published workspace structure). The template is published from a separate published workspace for security reasons; the primary workspace can’t be published directly. The build also notes that some fields may not transfer automatically when publishing, so fields like generic fields may need manual relocation.

Review Questions

  1. If Source status is unset on a new Source node, what downstream UI behavior breaks, and how is it corrected?
  2. How does the “part of” relationship for Concepts enable recursive discovery through live searches?
  3. What formatting constraints does the AI prompt require so Tana can turn AI output into linked topic nodes?

Key Points

  1. 1

    Build the schema around three super tags—Source, Highlight, and Fleeting Note—so every insight stays traceable to its origin.

  2. 2

    Use a **Source status** options field plus per-option emoji icons, then feed the icon into “build title from fields” for instant visual progress tracking.

  3. 3

    Separate **Topics** (instantiated tags for highlights) from **Concepts** (topics with added structure like recursive “part of” relationships).

  4. 4

    Use live searches to turn raw graph data into dashboards such as a Bookshelf and a daily “recent activity” panel.

  5. 5

    Add AI-enhanced topic extraction by returning 1–3 topics in a markdown code block, with each topic wrapped in double square brackets so Tana can link or create nodes.

  6. 6

    When publishing as a template, move super tags and live searches into the published workspace structure and publish from a separate read-only workspace for safety.

Highlights

Status icons aren’t just decoration: they’re driven by an emoji field per Source status option and injected into node titles via “build title from fields.”
Concepts become more than tags by adding a recursive “part of” field and using live searches with semantic function queries to resolve multi-level relationships.
AI topic extraction works reliably when the prompt forces a strict output format (markdown code block + double-square-bracket topic names), enabling Tana to link/create topic nodes automatically.
A Bookshelf dashboard can be built entirely from live searches filtered by Source status, letting one view replace multiple manual lists.
Publishing the system as a template requires careful nesting of super tags and live searches under the node being shared, plus using a separate published workspace for security.

Topics