Add node to Canvas (filesystem-native, offline).

Add a Dataview inline field to a note (filesystem-native, offline).

Creates a new Dataview field using the specified syntax variant. Automatically detects and preserves value types (number, boolean, date, etc.).

Syntax variants:

• full-line: field:: value (standalone line, most common)

• bracket: [field:: value] (inline, visible in reading mode)

• paren: (field:: value) (inline, hidden key in reading mode)

Insertion positions:

• after_frontmatter: After YAML frontmatter (or start if none)

• start: Very beginning of file

• end: Very end of file

When to use:

• Adding metadata to existing notes

• Batch tagging/categorization

• Automated property assignment

• Template-based field injection

Returns: Success status, formatted field string, and canonical key

Add a new card to a Kanban board column (filesystem-native, offline).

Creates a new card with optional metadata and inserts it at the specified position in the target column. Preserves all existing cards and board structure.

Card format:

• Incomplete: - [ ] Card text

• Completed: - [x] Card text

• With metadata: - [ ] Card text @{2025-10-30} #tag [[link]]

When to use:

• Adding tasks to project boards

• Batch card creation

• Automated workflow management

• Template-based board setup

Performance:

• < 500ms for boards with 1,000 cards

Returns: Success status, column name, position, and formatted card line

Add a tag to a note's frontmatter.

Creates frontmatter if it doesn't exist. Handles duplicate tags gracefully. Supports nested tags (e.g., "project/active/critical").

When to use:

• Adding tags to organize notes

• Bulk tagging operations

• Automated note categorization

Performance: < 200ms per operation

Returns: Success status and descriptive message

Add tags to a note's frontmatter.

When to use:

• Organizing notes with tags

• Bulk tagging operations

• Adding metadata for search

When NOT to use:

• Adding tags in note content (use update_note)

• Replacing all tags (use update_note with new frontmatter)

Returns: Updated tag list for the note

Analyze vault-wide link health metrics (filesystem-native, offline).

Provides comprehensive vault health analysis including:

• Total notes and links

• Orphaned notes count

• Notes with no inlinks/outlinks

• Broken links count

• Average links per note

• Link density score

When to use:

• Vault health assessment

• Identifying maintenance needs

• Tracking vault evolution over time

• Understanding vault connectivity

Performance:

• 1,000 notes: < 15 seconds

• 10,000 notes: < 150 seconds

Returns: Comprehensive health metrics with counts and averages

Extract all tags (frontmatter and inline) from a specific note.

This tool analyzes a note's content and extracts:

• Frontmatter tags (from YAML tags field)

• Inline tags (#tag syntax in content)

• Deduplicated list of all tags

When to use:

• Understanding what tags a note has

• Before adding tags to avoid duplicates

• Analyzing tag usage patterns

Performance: < 100ms per note

Returns: Tags organized by source (frontmatter, inline, all)

Append content to the end of a note.

Adds content at the very end of the file. Useful for adding appendices, logs, or any content that should come after all existing content.

When to use:

• Adding appendices or footnotes

• Appending log entries

• Building chronological content

• Adding content when position doesn't matter

Performance:

• Any note size: < 100ms

Returns: Success status and descriptive message

Create a new folder in the vault, including all parent folders in the path.

When to use:

• Setting up project structure in advance

• Creating deep folder hierarchies (e.g., "Apple/Studies/J71P")

• Creating archive folders before moving notes

• Establishing organizational hierarchy

• Preparing folders for future content

When NOT to use:

• If you're about to create a note in that path (folders are created automatically)

• For temporary organization (just create notes directly)

Note: Will create all necessary parent folders. For example, "Apple/Studies/J71P" will create Apple, Apple/Studies, and Apple/Studies/J71P if they don't exist.

Returns: Creation status with list of folders created and placeholder file path

Create a new note or overwrite an existing one.

When to use:

• Creating new notes with specific content

• Setting up templates or structured notes

• Programmatically generating documentation

When NOT to use:

• Updating existing notes (use update_note unless you want to replace entirely)

• Appending content (use update_note with merge_strategy="append")

Returns: Created note information with path and metadata

Create a new task with Tasks plugin metadata (filesystem-native, offline).

Creates a checkbox task with optional metadata (priority, dates, recurrence) and inserts it at the specified location in the file. Creates the file if it doesn't exist.

Metadata will be formatted using Tasks plugin emoji syntax:

• Priority: ⏫🔼🔽⏬ emojis

• Dates: 📅⏳🛫✅➕ emojis with YYYY-MM-DD

• Recurrence: 🔁 emoji with pattern

When to use:

• Adding tasks to project notes

• Creating recurring task templates

• Batch task creation

• Automated task generation

Returns: Success status, formatted task line, line number, and file path

Delete a note from the vault.

Args: path: Path to the note to delete

Returns: Deletion status

Execute Obsidian command (requires Obsidian running).

Execute a Dataview Query Language (DQL) query (requires Obsidian + Dataview plugin).

Executes full DQL queries with all Dataview plugin capabilities:

• LIST: Simple page lists

• TABLE: Tabular data views

• TASK: Task queries

• CALENDAR: Date-based views

Supports all DQL clauses: FROM, WHERE, SORT, LIMIT, GROUP BY

When to use:

• Complex queries beyond filesystem capabilities

• Leveraging Dataview's computed fields

• Accessing Dataview's metadata indices

• Real-time query results

Requires:

• Obsidian running

• Dataview plugin installed and enabled

• Local REST API plugin enabled

Returns: Query results in Dataview's structured format

Expand template variables (filesystem-native, offline).

Extract all Dataview inline fields from a note (filesystem-native, offline).

Parses all three Dataview inline field syntax variants:

• Full-line: field:: value

• Bracket: [field:: value] (inline, visible)

• Paren: (field:: value) (inline, hidden key)

Automatically detects value types:

• String, number, boolean, date (ISO8601)

• Wikilink: [[note]]

• List: "item1", "item2" or item1, item2

Skips code blocks to avoid false matches.

When to use:

• Extracting metadata from notes

• Auditing field usage

• Migrating to frontmatter

• Understanding note properties

Performance:

• Single note: < 100ms

• Processes up to 10,000 fields per second

Returns: All fields with keys, values, types, syntax variants, and line numbers

Find all broken links in the vault or a specific directory.

When to use:

• After renaming or deleting notes

• Regular vault maintenance

• Before reorganizing folder structure

• Cleaning up after imports

When NOT to use:

• Checking links in a single note (use get_outgoing_links with check_validity)

• Finding backlinks (use get_backlinks)

Returns: All broken links grouped by source note

Find hub notes with high outlink counts (filesystem-native, offline).

Identifies notes that link to many other notes (hubs/MOCs/index notes). These are typically index pages, maps of content, or navigation notes.

When to use:

• Finding index/MOC notes

• Identifying central navigation points

• Understanding information architecture

• Discovering organizational structures

Performance:

• 1,000 notes: < 10 seconds

• 10,000 notes: < 100 seconds

Returns: List of hub notes sorted by outlink count (highest first)

Find orphaned notes with no connections (filesystem-native, offline).

Identifies notes that have neither inlinks nor outlinks - completely isolated notes that aren't referenced anywhere and don't reference anything else.

When to use:

• Vault cleanup and maintenance

• Finding forgotten or unused notes

• Identifying candidates for archiving

• Improving vault connectivity

Performance:

• 1,000 notes: < 10 seconds

• 10,000 notes: < 100 seconds

Returns: List of orphaned notes with file paths

Get currently active file (requires Obsidian running).

Find all notes that link to a specified note (filesystem-native, no Obsidian required).

This tool uses direct filesystem access for maximum performance and works without requiring Obsidian to be running. It scans all markdown files in the vault to find wikilinks pointing to the target note.

When to use:

• Finding which notes reference a specific concept/note

• Building connection graphs without Obsidian running

• High-performance backlink discovery for large vaults

• Batch processing multiple notes

Performance:

• 1,000 notes: < 2 seconds

• 10,000 notes: < 20 seconds

Returns: All notes containing wikilinks to the target note with context

Find all notes that link to a specific note (backlinks).

When to use:

• Understanding which notes reference a concept or topic

• Discovering relationships between notes

• Finding notes that depend on the current note

• Building a mental map of note connections

When NOT to use:

• Finding links FROM a note (use get_outgoing_links)

• Searching for broken links (use find_broken_links)

Performance note:

• Fast for small vaults (<100 notes)

• May take several seconds for large vaults (1000+ notes)

• Consider using search_notes for specific link queries

Returns: All notes linking to the target with optional context

Find all broken wikilinks in the vault (filesystem-native, no Obsidian required).

This tool uses direct filesystem access to scan all markdown files and identify wikilinks pointing to non-existent notes. Works without requiring Obsidian to be running.

When to use:

• After renaming or deleting notes

• Regular vault maintenance and cleanup

• Before reorganizing folder structures

• Identifying orphaned link references

Performance:

• 1,000 notes: < 10 seconds

• 10,000 notes: < 100 seconds

Returns: All broken links grouped by source note

Get comprehensive statistics for a Kanban board (filesystem-native, offline).

Analyzes the board and provides:

• Total cards, completed, incomplete counts

• Per-column card counts and completion rates

• Overall board completion percentage

• Column names and structure

When to use:

• Project progress tracking

• Sprint velocity analysis

• Board health monitoring

• Generating board reports

Performance:

• Boards with 100 cards: < 500ms

• Boards with 1,000 cards: < 5 seconds

Returns: Comprehensive board statistics with counts and percentages

Get complete link graph for the vault (filesystem-native, offline).

Builds a comprehensive graph of all note connections, tracking:

• Inlinks (notes linking TO each note)

• Outlinks (notes linked FROM each note)

• Link types (wikilinks, markdown links, embeds)

When to use:

• Understanding vault structure and relationships

• Analyzing note connectivity

• Building visualization data

• Identifying connection patterns

Performance:

• 1,000 notes: < 10 seconds

• 10,000 notes: < 100 seconds

Returns: Complete link graph with all note connections and link type counts

Get connection graph for a specific note (filesystem-native, offline).

Explores connections from a note up to specified depth:

• Depth 1: Direct connections (notes linked from target)

• Depth 2: Second-degree connections (notes linked from direct connections)

• Depth 3: Third-degree connections

Provides both inlinks (backlinks) and outlinks with depth information.

When to use:

• Understanding note relationships

• Exploring local note neighborhoods

• Finding related content

• Building connection visualizations

Performance:

• Depth 1: < 1 second

• Depth 2: < 5 seconds

• Depth 3: < 30 seconds

Returns: Connection graph with multi-level links and depth annotations

Get metadata and information about a note without retrieving its full content.

Args: path: Path to the note

Returns: Note metadata and statistics

List all links from a specific note (outgoing links).

When to use:

• Understanding what a note references

• Checking note dependencies before moving/deleting

• Exploring the structure of index or hub notes

• Validating links after changes

When NOT to use:

• Finding notes that link TO this note (use get_backlinks)

• Searching across multiple notes (use find_broken_links)

Returns: All outgoing links with their types and optional validity status

Get aggregate task statistics for a note or entire vault (filesystem-native).

Analyzes all tasks and provides:

• Total, incomplete, completed counts

• Breakdown by priority level

• Overdue tasks (past due date, still incomplete)

• Upcoming tasks (due within 7 days)

• Recurring tasks count

• Optional grouped data

When to use:

• Project progress tracking

• Workload analysis

• Finding overdue tasks

• Weekly planning

Performance:

• Single note: < 100ms

• Vault (1,000 notes): < 5 seconds

Returns: Comprehensive task statistics with counts and optional grouping

Insert content immediately after a block reference.

Finds the specified block reference (^block-id) and inserts content after the line containing it. Accepts block IDs with or without the ^ prefix.

When to use:

• Adding follow-up content to referenced blocks

• Expanding on specific paragraphs

• Building linked content structures

• Programmatic content generation

Performance:

• 10,000 word notes: < 500ms

Returns: Success status and descriptive message

Insert content immediately after a specific heading in a note.

Finds the specified heading (case-sensitive) and inserts content on the line immediately following it. If multiple headings with the same text exist, content is inserted after the first occurrence.

When to use:

• Adding tasks to a "Tasks" section

• Inserting notes under a "Notes" heading

• Appending content to specific sections

• Building structured content programmatically

Performance:

• 10,000 word notes: < 500ms

Returns: Success status and descriptive message

List all available commands (requires Obsidian running).

List folders in the vault or a specific directory.

When to use:

• Exploring vault organization structure

• Verifying folder names before creating notes

• Checking if a specific folder exists

• Understanding the hierarchy of the vault

When NOT to use:

• Listing notes (use list_notes instead)

• Searching for content (use search_notes)

Returns: Folder structure with paths and names

List notes in a folder using DQL (requires Obsidian + Dataview plugin).

Simplified interface for folder-based queries with optional filtering and sorting.

When to use:

• Finding notes in specific folders with filters

• Leveraging Dataview's folder indexing

• Real-time folder queries

Returns: List of matching notes with Dataview metadata

List notes with a specific tag using DQL (requires Obsidian + Dataview plugin).

Simplified interface for tag-based queries with optional filtering and sorting.

When to use:

• Finding notes by tag with complex filters

• Leveraging Dataview's tag indexing

• Real-time tag queries

Returns: List of matching notes with Dataview metadata

List notes in the vault or a specific directory.

Args: directory: Specific directory to list (optional, defaults to root) recursive: Whether to list all subdirectories recursively (default: true)

Returns: Vault structure and note paths

List all unique tags used across the vault with usage statistics.

When to use:

• Before adding tags to maintain consistency

• Getting an overview of your tagging taxonomy

• Finding underused or overused tags

• Discovering tag variations (e.g., 'project' vs 'projects')

When NOT to use:

• Getting tags for a specific note (use get_note_info)

• Searching notes by tag (use search_notes with tag: prefix)

Performance note:

• For vaults with <1000 notes: Fast (1-3 seconds)

• For vaults with 1000-5000 notes: Moderate (3-10 seconds)

• For vaults with >5000 notes: May be slow (10+ seconds)

• Uses batched concurrent requests to optimize performance

Returns: All unique tags with optional usage counts

List available templates (filesystem-native, offline).

Move an entire folder and all its contents to a new location.

When to use:

• Reorganizing vault structure

• Archiving completed projects

• Consolidating related notes

• Seasonal organization (e.g., moving to year-based archives)

When NOT to use:

• Moving individual notes (use move_note instead)

• Moving to a subfolder of the source (creates circular reference)

Returns: Move status with count of notes and folders moved

Move a card between columns on a Kanban board (filesystem-native, offline).

Finds a card by matching its text, removes it from the source column, and adds it to the destination column. Preserves all metadata, subtasks, and formatting.

When to use:

• Moving tasks through workflow stages

• Dragging cards between columns programmatically

• Batch workflow updates

• Automated status changes

Performance:

• < 500ms for boards with 1,000 cards

Returns: Success status, source/destination columns, and card details

Move a note to a new location, optionally updating all links.

Args: source_path: Current path of the note destination_path: New path for the note update_links: Whether to update links in other notes (default: true)

Returns: Move status and updated links count

Get comprehensive statistics about a single note.

Analyzes the note for words, characters, lines, links (wikilinks and markdown), tags (frontmatter and inline), headings, code blocks, and file metadata.

Returns detailed metrics including:

• Word count (excluding frontmatter and code blocks)

• Character counts (with and without spaces)

• Line count

• Links: wikilinks, markdown links, total links

• Tags: frontmatter and inline tags

• Headings: count, by level, structure

• Code: fenced code blocks and inline code

• File metadata: size, timestamps

When to use:

• Analyzing individual note complexity

• Tracking note growth over time

• Understanding note structure

• Content auditing

Performance:

• Any note size: < 1 second

Returns: Comprehensive statistics dictionary

Open file in Obsidian (requires Obsidian running).

Parse Canvas file (filesystem-native, offline).

Parse a Kanban board file and extract its structure (filesystem-native, offline).

Parses markdown-based Kanban boards with the following structure:

• Column Name (level 2 or 3 headings)

• Card text with metadata

  • Nested subtask

Metadata formats:

• Due dates: @{YYYY-MM-DD}

• Tags: #tag (inline)

• Wikilinks: [[note]]

Supports nested subtasks with indentation levels.

When to use:

• Analyzing board structure

• Extracting card data programmatically

• Generating board reports

• Understanding card relationships

Performance:

• Boards with 100 cards: < 500ms

• Boards with 1,000 cards: < 5 seconds

Returns: Board structure with columns, cards, subtasks, metadata, and statistics

Read the content and metadata of a specific note.

When to use:

• Displaying note contents to the user

• Analyzing or processing existing note data

• ALWAYS before updating a note to preserve existing content

• Verifying a note exists before making changes

When NOT to use:

• Searching multiple notes (use search_notes instead)

• Getting only metadata (use get_note_info for efficiency)

Returns: Note content and metadata including tags, aliases, and frontmatter

Remove a Dataview inline field from a note (filesystem-native, offline).

Removes all occurrences of a field by key (canonicalized matching), or a specific occurrence if line_number is provided.

For inline fields (bracket/paren syntax), removes only the field while preserving surrounding text. For full-line fields, removes the entire line.

When to use:

• Cleaning up obsolete metadata

• Removing duplicate fields

• Migrating fields to frontmatter

• Batch field removal

Returns: Success status, removed key, and canonical key

Remove a tag from a note's frontmatter.

Handles non-existent tags gracefully. Only removes from frontmatter, not inline tags in content.

When to use:

• Cleaning up old tags

• Reorganizing tag taxonomy

• Bulk tag removal operations

Performance: < 200ms per operation

Returns: Success status and descriptive message

Remove tags from a note's frontmatter.

Args: path: Path to the note tags: List of tags to remove (without # prefix)

Returns: Updated tag list

Render Templater template (requires Obsidian + Templater plugin).

Find all notes containing a specific Dataview field (filesystem-native, offline).

Searches across all markdown files in the vault for a field by key (and optionally value/type). Field keys are canonicalized for consistent matching:

• "Project Status" → "project-status"

• "Due Date" → "due-date"

When to use:

• Finding notes with specific metadata

• Discovering field usage patterns

• Locating notes by custom properties

• Building dynamic collections

Performance:

• 1,000 notes: < 5 seconds

• 10,000 notes: < 50 seconds

Returns: Matching fields grouped by file, with total counts and file list

Search for notes by creation or modification date.

When to use:

• Finding recently modified notes

• Locating notes created in a specific time period

• Reviewing activity from specific dates

When NOT to use:

• Content-based search (use search_notes)

• Finding notes by tags or path (use search_notes)

Returns: Notes matching the date criteria with paths and timestamps

Find all notes containing a specific tag (frontmatter or inline).

Searches entire vault for notes with the specified tag in either frontmatter or inline (#tag) format. Supports nested tags.

When to use:

• Finding all notes in a category

• Building tag-based navigation

• Analyzing tag usage across vault

• Finding related notes

Performance:

• 1,000 notes: < 3 seconds

• 10,000 notes: < 30 seconds

Returns: List of notes with tag locations (frontmatter/inline)

Search for notes containing specific text or matching search criteria.

When to use:

• Finding notes by content keywords

• Locating notes with specific tags

• Searching within specific folders

When NOT to use:

• Searching by date (use search_by_date instead)

• Listing all notes (use list_notes for better performance)

• Finding a specific known note (use read_note directly)

Returns: Search results with matched notes, relevance scores, and context

Search and filter tasks by metadata across the vault (filesystem-native, offline).

Scans all markdown files in the vault and extracts tasks with Tasks plugin metadata (due dates, priorities, recurrence). Supports comprehensive filtering and sorting.

Metadata Format (Tasks Plugin):

• Priority: ⏫ (highest), 🔼 (high), 🔽 (low), ⏬ (lowest), none (normal)

• Due date: 📅 YYYY-MM-DD

• Scheduled: ⏳ YYYY-MM-DD

• Start date: 🛫 YYYY-MM-DD

• Done date: ✅ YYYY-MM-DD

• Recurrence: 🔁 every

When to use:

• Finding overdue tasks

• Viewing high-priority tasks

• Planning weekly schedules

• Reviewing recurring tasks

Performance:

• 1,000 notes: < 3 seconds

• 10,000 notes: < 30 seconds

Returns: Tasks matching filters with full metadata, file locations, and line numbers

Execute a DQL TABLE query (requires Obsidian + Dataview plugin).

Creates tabular views of note metadata with custom fields.

When to use:

• Creating structured data views

• Displaying multiple fields in table format

• Building reports and dashboards

• Analyzing note collections

Returns: Table results with specified fields and rows

Toggle a Kanban card's completion status (filesystem-native, offline).

Toggles the checkbox between - [ ] (incomplete) and - [x] (completed). Preserves all metadata, subtasks, and formatting.

When to use:

• Marking cards complete/incomplete

• Batch status updates

• Automated workflow transitions

• Quick status changes

Performance:

• < 500ms for boards with 1,000 cards

Returns: Success status, new status, and card details

Toggle task completion status between incomplete and completed (filesystem-native).

Toggles the checkbox between - [ ] (incomplete) and - [x] (completed). Optionally adds a done date (✅ YYYY-MM-DD) when marking tasks as complete.

When to use:

• Marking tasks complete

• Unchecking accidentally completed tasks

• Batch status updates via automation

Returns: Success status, new status, done date (if added), and updated line

Update or add a field in note's YAML frontmatter.

If the note has no frontmatter, it will be created. If the field already exists, its value will be updated. Otherwise, the field will be added. Supports strings, numbers, booleans, and lists.

When to use:

• Updating note status or metadata

• Adding creation/modification timestamps

• Managing custom frontmatter fields

• Programmatic metadata management

Performance:

• Any note size: < 200ms

Returns: Success status and descriptive message

Update the content of an existing note.

⚠️ IMPORTANT: By default, this REPLACES the entire note content. Always read the note first if you need to preserve existing content.

When to use:

• Updating a note with completely new content (replace)

• Adding content to the end of a note (append)

• Programmatically modifying notes

When NOT to use:

• Making small edits (read first, then update with full content)

• Creating new notes (use create_note instead)

Returns: Update status with path, metadata, and operation performed

Update tags on a note - either replace all tags or merge with existing.

When to use:

• After analyzing a note's content to suggest relevant tags

• Reorganizing tags across your vault

• Setting consistent tags based on note types or projects

• AI-driven tag suggestions ("What is this note about? Add appropriate tags")

When NOT to use:

• Just adding a few tags (use add_tags)

• Just removing specific tags (use remove_tags)

Returns: Previous tags, new tags, and operation performed

Update task metadata without changing the task content (filesystem-native).

Updates priority, dates, or recurrence patterns while preserving the task description. Pass null/None to remove metadata fields.

When to use:

• Rescheduling tasks

• Changing task priorities

• Adding/removing recurrence

• Batch metadata updates

Returns: Success status, updated line, and list of changes made

Get aggregate statistics for the entire vault.

Walks through the vault directory, analyzes all markdown files (excluding .obsidian), and aggregates statistics. Uses memory-efficient generator-based iteration.

Returns:

• Total notes count

• Total words across all notes

• Total links (wikilinks + markdown links)

• Unique tags count and sorted list

• Average words per note

When to use:

• Understanding vault size and complexity

• Content inventory and auditing

• Identifying most-used tags

• Tracking vault growth

Performance:

• 1,000 notes: < 30 seconds

• 10,000 notes: < 5 minutes

Returns: Vault-wide aggregate statistics