Obsidian Vault Management

Obsidian Vault Management

Vault Structure (PARA-Based)

This vault uses a PARA-like organization:

Quick Reference

Linking Syntax

[[Note Name]]                    # Basic wikilink
[[Note Name|Display Text]]       # Aliased link
[[Note Name#Heading]]            # Link to heading
[[Note Name#^block-id]]          # Link to block
![[Note Name]]                   # Embed note
![[image.png]]                   # Embed image
![[Note Name#Heading]]           # Embed section

Frontmatter Template

---
created: {{date:YYYY-MM-DDTHH:mm}}
updated: {{date:YYYY-MM-DDTHH:mm}}
title: "Note Title"
type: note
status: draft
tags:
  - tag1
  - tag2
aliases:
  - "Alternate Name"
cssclasses:
  - custom-class
---

Callouts

> [!note] Title
> Content

> [!warning] Important
> Warning content

> [!tip] Helpful tip
> Tip content

> [!info]+ Collapsible (open by default)
> Content

> [!danger]- Collapsed by default
> Content

Available callout types: note, abstract, info, todo, tip, success, question, warning, failure, danger, bug, example, quote

Creating Notes

Daily Note

Create in 06 - Daily/YYYY/MM/ with filename YYYYMMDD.md:

---
created: 2025-12-09T09:00
updated: 2025-12-09T09:00
title: "20251209"
type: daily-note
status: true
tags:
  - daily
  - journal
  - 2025
  - 2025-12
aliases:
  - "2025-12-09"
date_formatted: 2025-12-09
topics:
  - "[[daily]]"
  - "[[journal]]"
related:
  - "[[2025-12-08]]"
  - "[[2025-12-10]]"
cssclasses:
  - daily
---

# Daily Note - 2025-12-09

### Tasks
- [ ] Task 1

### Journal
...

### Navigation
<< [[2025-12-08]] | **Today** | [[2025-12-10]] >>

Zettelkasten Note

Create in 04 - Permanent/:

---
created: {{date}}
type: zettelkasten
tags:
  - permanent
  - topic
---

# Note Title

## Main Insight
**Key Idea**: [Main point]

## Connections
- [[Related Note 1]]
- [[Related Note 2]]

## References
- Source citation

Dataview Queries

For dataview query syntax, see references/dataview.md.

Quick examples:

LIST FROM "06 - Daily" WHERE file.cday = date(today) SORT file.ctime DESC

TABLE status, tags FROM "01 - Projects" WHERE status != "completed"

Templates

Templates location: 99 - Meta/00 - Templates/

For Templater syntax, see references/templater.md.

Common Templater variables:

<% tp.file.title %>              # Current file name
<% tp.date.now("YYYY-MM-DD") %>  # Current date
<% tp.file.cursor(1) %>          # Cursor position
<% tp.system.prompt("Question") %> # User input prompt

Installed Plugins

File Operations

Creating a Note

1. Determine appropriate folder based on note type 2. Add proper frontmatter 3. Use consistent naming conventions 4. Include relevant tags for auto-organization

Best Practices

• Use descriptive filenames (avoid special characters except hyphens)
• Always include created and updated timestamps
• Tag notes for discoverability
• Link to related notes bidirectionally
• Use callouts for important information
• Include navigation links in daily notes

Advanced Features

• Dataview queries: references/dataview.md
• Templater scripting: references/templater.md
• Canvas diagrams: references/canvas.md
• Plugin configurations: references/plugins.md

---

Gotchas

• Bulk operations outside Obsidian don't trigger link-rebuilding — external scripts must signal a :Reindex or wait for the next vault open.
• Dataview cache is per-vault and per-session — CLI script-based DQL queries may see stale state if Obsidian was last open with different filters.
• Templater scripts via CLI run in a different context than the UI — many tp.system.* functions return nil (no UI to prompt against).
• PARA folder moves break tag-based queries — if your queries hardcode folder paths, refactor them to use tags or properties before reorganizing.
• Daily note rotation: changing the daily-note format mid-vault leaves old notes orphaned — they don't auto-migrate to the new format; a rename pass is needed.

Obsidian Canvas Reference

Canvas is a visual tool for spatially organizing notes, images, and other content.

File Format

Canvas files use .canvas extension and store JSON data:

{
  "nodes": [],
  "edges": []
}

Node Types

Text Node

{
  "id": "unique-id",
  "type": "text",
  "x": 0,
  "y": 0,
  "width": 250,
  "height": 100,
  "text": "Your text content here"
}

File Node (Embed Note)

{
  "id": "unique-id",
  "type": "file",
  "file": "path/to/note.md",
  "x": 300,
  "y": 0,
  "width": 400,
  "height": 300
}

Link Node (Web Embed)

{
  "id": "unique-id",
  "type": "link",
  "url": "https://example.com",
  "x": 0,
  "y": 200,
  "width": 400,
  "height": 300
}

Group Node

{
  "id": "unique-id",
  "type": "group",
  "x": -50,
  "y": -50,
  "width": 600,
  "height": 400,
  "label": "Group Name"
}

Edges (Connections)

{
  "id": "edge-id",
  "fromNode": "source-node-id",
  "fromSide": "right",
  "toNode": "target-node-id",
  "toSide": "left",
  "color": "1",
  "label": "Connection label"
}

Side Options

• top
• right
• bottom
• left

Color Options

Canvas uses numbered colors 1-6:

• 1: Red
• 2: Orange
• 3: Yellow
• 4: Green
• 5: Cyan
• 6: Purple

Node Colors

Add color property to any node:

{
  "id": "node-id",
  "type": "text",
  "color": "1",
  "text": "Red text card"
}

Complete Canvas Example

{
  "nodes": [
    {
      "id": "1",
      "type": "text",
      "x": 0,
      "y": 0,
      "width": 200,
      "height": 100,
      "text": "# Main Idea\n\nCore concept description"
    },
    {
      "id": "2",
      "type": "file",
      "file": "04 - Permanent/concept-note.md",
      "x": 300,
      "y": 0,
      "width": 300,
      "height": 200
    },
    {
      "id": "3",
      "type": "text",
      "x": 0,
      "y": 150,
      "width": 200,
      "height": 80,
      "text": "Related thought",
      "color": "4"
    },
    {
      "id": "group1",
      "type": "group",
      "x": -20,
      "y": -20,
      "width": 640,
      "height": 280,
      "label": "Knowledge Cluster"
    }
  ],
  "edges": [
    {
      "id": "e1",
      "fromNode": "1",
      "fromSide": "right",
      "toNode": "2",
      "toSide": "left",
      "label": "expands on"
    },
    {
      "id": "e2",
      "fromNode": "1",
      "fromSide": "bottom",
      "toNode": "3",
      "toSide": "top",
      "color": "4"
    }
  ]
}

Creating Canvas Programmatically

Basic Structure

import json

canvas = {
    "nodes": [],
    "edges": []
}

# Add nodes
canvas["nodes"].append({
    "id": "node1",
    "type": "text",
    "x": 0,
    "y": 0,
    "width": 250,
    "height": 100,
    "text": "Content here"
})

# Save
with open("my-canvas.canvas", "w") as f:
    json.dump(canvas, f, indent=2)

Grid Layout Helper

def create_grid_canvas(items, cols=3, card_width=250, card_height=100, gap=50):
    nodes = []
    for i, item in enumerate(items):
        row = i // cols
        col = i % cols
        nodes.append({
            "id": f"node-{i}",
            "type": "text",
            "x": col * (card_width + gap),
            "y": row * (card_height + gap),
            "width": card_width,
            "height": card_height,
            "text": item
        })
    return {"nodes": nodes, "edges": []}

Best Practices

1. Use groups to organize related nodes 2. Color-code by category or status 3. Keep text concise in text nodes 4. Embed notes for detailed content 5. Label edges for relationship clarity 6. Maintain spacing for readability

Canvas Use Cases

• Mind mapping: Brainstorm and connect ideas
• Project planning: Visual task boards
• Knowledge graphs: Visualize note relationships
• Mood boards: Collect visual inspiration
• Architecture diagrams: System design
• Flowcharts: Process documentation

Dataview Query Reference

Query Types

LIST Query

LIST
FROM "folder"
WHERE condition
SORT field ASC/DESC
LIMIT 10

TABLE Query

TABLE col1, col2, col3
FROM "folder"
WHERE condition
SORT field DESC

TASK Query

TASK
FROM "folder"
WHERE !completed
GROUP BY file.link

CALENDAR Query

CALENDAR file.cday
FROM "06 - Daily"

Source Selection (FROM)

FROM "folder"                    # Specific folder
FROM #tag                        # Notes with tag
FROM [[Note]]                    # Notes linking to Note
FROM outgoing([[Note]])          # Notes linked from Note
FROM "folder" AND #tag           # Combine with AND
FROM "folder" OR "other"         # Combine with OR
FROM -"excluded"                 # Exclude folder

Field Access

Implicit Fields (automatic)

Frontmatter Fields

Access YAML frontmatter directly:

TABLE status, created, tags
FROM "01 - Projects"

Inline Fields

Define inline fields in notes:

Key:: Value
[Key:: Value]
(Key:: Value)

Access in queries: WHERE key = "value"

WHERE Conditions

WHERE file.name = "exact"
WHERE contains(file.name, "partial")
WHERE startswith(file.name, "prefix")
WHERE endswith(file.name, "suffix")
WHERE file.cday = date(today)
WHERE file.cday >= date(today) - dur(7 days)
WHERE contains(tags, "#important")
WHERE status != "completed"
WHERE !completed                  # For tasks
WHERE length(file.tags) > 2
WHERE any(file.tags, (t) => startswith(t, "#project"))

SORT Options

SORT file.name ASC
SORT file.mtime DESC
SORT status ASC, priority DESC   # Multiple fields

GROUP BY

TABLE rows.file.link
FROM "folder"
GROUP BY status

Date Functions

date(today)                      # Today
date(now)                        # Current datetime
date(tomorrow)                   # Tomorrow
date(yesterday)                  # Yesterday
date("2025-12-09")               # Specific date
dur(7 days)                      # Duration
dur(1 week)                      # Duration
file.cday.year                   # Extract year
file.cday.month                  # Extract month
file.cday.day                    # Extract day

String Functions

contains(string, "search")
startswith(string, "prefix")
endswith(string, "suffix")
replace(string, "old", "new")
lower(string)
upper(string)
length(string)
split(string, ",")
join(list, ", ")

List Functions

length(list)
contains(list, item)
all(list, condition)
any(list, condition)
filter(list, condition)
map(list, function)
sort(list)
reverse(list)
flat(nested-list)

Inline Queries

Use prefix = for inline queries (configured in vault):

Today is `= date(today)`
File count: `= length(filter(file.tasks, (t) => !t.completed))`

DataviewJS

For complex queries, use dataviewjs code blocks:

const pages = dv.pages('"06 - Daily"')
  .where(p => p.file.cday >= dv.date('2025-01-01'))
  .sort(p => p.file.cday, 'desc');

dv.table(
  ["Date", "Tasks"],
  pages.map(p => [p.file.link, p.file.tasks.length])
);

Common Patterns

Recent Daily Notes

LIST
FROM "06 - Daily"
WHERE file.cday >= date(today) - dur(7 days)
SORT file.cday DESC

Incomplete Tasks by Project

TASK
FROM "01 - Projects"
WHERE !completed
GROUP BY file.link

Notes Modified Today

TABLE file.mtime as "Modified"
WHERE file.mday = date(today)
SORT file.mtime DESC

Tag Overview

TABLE length(rows) as "Count"
FROM "vault"
FLATTEN file.tags as tag
GROUP BY tag
SORT length(rows) DESC

Notes Created This Month

LIST
WHERE file.cday.year = date(today).year
WHERE file.cday.month = date(today).month
SORT file.cday DESC

Installed Plugins Reference

Dataview

Purpose: Query notes like a database

Config file: .obsidian/plugins/dataview/data.json

Key Settings:

• Inline query prefix: =
• Inline JS prefix: $=
• Date format: MMMM dd, yyyy
• Task completion tracking: enabled

See dataview.md for query syntax.

Templater

Purpose: Advanced templates with scripting

Config file: .obsidian/plugins/templater-obsidian/data.json

Key Settings:

• Templates folder: 99 - Meta/00 - Templates
• Trigger on file creation: enabled
• Auto jump to cursor: enabled

See templater.md for syntax.

Auto Note Mover

Purpose: Automatically move notes based on tags

Config file: .obsidian/plugins/auto-note-mover/data.json

Current Rules:

Periodic Notes

Purpose: Daily, weekly, monthly note management

Config file: .obsidian/plugins/periodic-notes/data.json

Typical Settings:

• Daily notes folder: 06 - Daily/{{date:YYYY}}/{{date:MM}}
• Daily note format: {{date:YYYYMMDD}}
• Template: daily note template

Kanban

Purpose: Kanban boards in markdown

Usage: Create a note with kanban content:

---
kanban-plugin: basic
---

## To Do

- [ ] Task 1
- [ ] Task 2

## In Progress

- [ ] Active task

## Done

- [x] Completed task

Tag Wrangler

Purpose: Bulk tag management

Features:

• Rename tags across vault
• Merge duplicate tags
• Delete unused tags
• Tag suggestions

Table Editor

Purpose: Easy markdown table editing

Features:

• Visual table editor
• Add/remove rows/columns
• Sort columns
• Align text

Advanced URI

Purpose: Deep links to notes and actions

URI Format:

obsidian://advanced-uri?vault=VAULT_NAME&filepath=path/to/note.md
obsidian://advanced-uri?vault=VAULT_NAME&daily=true
obsidian://advanced-uri?vault=VAULT_NAME&search=query

Local REST API

Purpose: External API access to vault

Config file: .obsidian/plugins/obsidian-local-rest-api/data.json

Endpoints (when enabled):

• GET /vault - List all files
• GET /vault/{path} - Get file content
• PUT /vault/{path} - Create/update file
• DELETE /vault/{path} - Delete file
• POST /search - Search vault

MetaEdit

Purpose: Edit frontmatter properties

Features:

• Quick property editing
• Auto-complete for values
• Kanban integration

Note Refactor

Purpose: Split and refactor notes

Features:

• Extract selection to new note
• Split by heading
• Automatic link updates

Update Time on Edit

Purpose: Auto-update timestamps

Config file: .obsidian/plugins/update-time-on-edit/data.json

Updates updated field in frontmatter on file save.

Frontmatter Tag Suggest

Purpose: Tag auto-complete in frontmatter

Features:

• Suggests existing tags
• Works in YAML frontmatter
• Reduces typos

Icon Folder

Purpose: Custom folder icons

Features:

• Assign icons to folders
• Custom icon packs
• Visual organization

List Callouts

Purpose: Callout styling for lists

Usage:

- [!] Important item
- [?] Question
- [i] Information

Smart Typography

Purpose: Auto-replace typography

Features:

• Smart quotes
• Em/en dashes
• Ellipsis
• Arrows

Style Settings

Purpose: Theme customization

Features:

• CSS variable controls
• Per-theme settings
• Live preview

URL Into Selection

Purpose: Paste URLs as links

Features:

• Select text, paste URL
• Creates [selected text](url)

Copilot (AI)

Purpose: AI-powered assistance

Features:

• Chat with notes
• Summarization
• Question answering
• Custom prompts stored in copilot-custom-prompts/

Plugin Management Tips

1. Disable unused plugins to improve performance 2. Check for updates regularly 3. Backup config before major changes 4. Test new plugins in a test vault first 5. Review settings after updates

Templater Reference

Configuration

Templates folder: 99 - Meta/00 - Templates/

Basic Syntax

All Templater commands use <% %> delimiters:

<% tp.module.function() %>

Output result: <% tp.module.function() %> Execute without output: <%* code %> Whitespace control: <%- %> or <% -%>

File Module (tp.file)

<% tp.file.title %>                        # Filename without extension
<% tp.file.path() %>                       # Full path
<% tp.file.path(true) %>                   # Relative path
<% tp.file.folder() %>                     # Parent folder name
<% tp.file.folder(true) %>                 # Full folder path
<% tp.file.content %>                      # File content
<% tp.file.selection() %>                  # Selected text
<% tp.file.cursor(1) %>                    # Cursor position (numbered)
<% tp.file.cursor_append("text") %>        # Append at cursor

<%* tp.file.create_new(template, filename, folder) %>  # Create file
<%* tp.file.move("/new/path") %>           # Move file
<%* tp.file.rename("new-name") %>          # Rename file
<%* await tp.file.exists("path") %>        # Check if exists

Date Module (tp.date)

<% tp.date.now() %>                        # Current datetime
<% tp.date.now("YYYY-MM-DD") %>            # Formatted date
<% tp.date.now("HH:mm") %>                 # Time only
<% tp.date.now("YYYY-MM-DD", 7) %>         # 7 days from now
<% tp.date.now("YYYY-MM-DD", -1) %>        # Yesterday
<% tp.date.now("dddd") %>                  # Day name
<% tp.date.now("MMMM") %>                  # Month name

<% tp.date.yesterday("YYYY-MM-DD") %>      # Yesterday
<% tp.date.tomorrow("YYYY-MM-DD") %>       # Tomorrow
<% tp.date.weekday("YYYY-MM-DD", 0) %>     # This week's Sunday

Date Format Tokens

System Module (tp.system)

<% tp.system.clipboard() %>                # Clipboard content
<% tp.system.prompt("Question") %>         # User input
<% tp.system.prompt("Question", "default") %>  # With default
<% tp.system.suggester(options, values) %> # Dropdown selection

Suggester Examples

<%*
const options = ["Option 1", "Option 2", "Option 3"];
const selected = await tp.system.suggester(options, options);
tR += selected;
%>

<%*
const types = {"Project": "01 - Projects", "Area": "02 - Areas"};
const selected = await tp.system.suggester(Object.keys(types), Object.values(types));
%>

Frontmatter Module (tp.frontmatter)

<% tp.frontmatter.title %>                 # Frontmatter field
<% tp.frontmatter["field-name"] %>         # Field with hyphen
<% tp.frontmatter.tags %>                  # Array field

Web Module (tp.web)

<% tp.web.daily_quote() %>                 # Random quote
<% tp.web.random_picture() %>              # Random image URL
<% tp.web.random_picture("200x200") %>     # Sized image

User Scripts

Create scripts in user scripts folder and call:

<% tp.user.my_script() %>
<% tp.user.my_script(arg1, arg2) %>

JavaScript Execution

Full JavaScript support:

<%*
const today = tp.date.now("YYYY-MM-DD");
const title = tp.file.title;

if (title.startsWith("Daily")) {
  tR += "# Daily Note\n";
} else {
  tR += "# " + title + "\n";
}
%>

Variables

• tR: Template result string (append to output)
• tp: Templater object with all modules

Template Examples

Daily Note Template

---
created: <% tp.date.now("YYYY-MM-DDTHH:mm") %>
updated: <% tp.date.now("YYYY-MM-DDTHH:mm") %>
title: "<% tp.file.title %>"
type: daily-note
tags:
  - daily
  - <% tp.date.now("YYYY") %>
  - <% tp.date.now("YYYY-MM") %>
aliases:
  - "<% tp.date.now("YYYY-MM-DD") %>"
---

# Daily Note - <% tp.date.now("YYYY-MM-DD") %>

## Tasks
- [ ] <% tp.file.cursor(1) %>

## Journal


## Navigation
<< [[<% tp.date.now("YYYY-MM-DD", -1) %>]] | **Today** | [[<% tp.date.now("YYYY-MM-DD", 1) %>]] >>

New Note Template

---
created: <% tp.date.now("YYYY-MM-DDTHH:mm") %>
updated: <% tp.date.now("YYYY-MM-DDTHH:mm") %>
title: "<% tp.file.title %>"
type: <%* const types = ["note", "project", "reference", "zettelkasten"]; tR += await tp.system.suggester(types, types); %>
status: draft
tags:
  - <% tp.file.cursor(2) %>
---

# <% tp.file.title %>

<% tp.file.cursor(1) %>

Meeting Notes Template

---
created: <% tp.date.now("YYYY-MM-DDTHH:mm") %>
type: meeting
attendees:
  -
project: "[[<% await tp.system.prompt("Project") %>]]"
---

# Meeting: <% await tp.system.prompt("Meeting Topic") %>

**Date**: <% tp.date.now("YYYY-MM-DD HH:mm") %>
**Attendees**:

## Agenda
1. <% tp.file.cursor(1) %>

## Notes


## Action Items
- [ ]

## Follow-up

Book Notes Template

---
created: <% tp.date.now("YYYY-MM-DDTHH:mm") %>
type: book
title: "<% await tp.system.prompt("Book Title") %>"
author: "<% await tp.system.prompt("Author") %>"
status: reading
rating: /5
---

# <% tp.frontmatter.title %>

**Author**: <% tp.frontmatter.author %>
**Started**: <% tp.date.now("YYYY-MM-DD") %>

## Summary


## Key Takeaways
1.
2.
3.

## Quotes


## Notes
<% tp.file.cursor(1) %>