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)

• Viewing images in a note (use view_note_images instead)

Returns: Note content and metadata including tags, aliases, and frontmatter. Image references () are preserved in the content but images are not loaded.

IMPORTANT: If the note contains image references, proactively offer to analyze them: "I can see this note contains [N] images. Would you like me to analyze/examine them for you?" Then use view_note_images to load and analyze the images if requested.

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

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

Edit a specific section of a note identified by a markdown heading.

When to use:

• Adding content to a specific section without rewriting the whole note

• Updating a particular section (like status updates, task lists)

• Inserting content at precise locations in structured notes

• Building up notes incrementally by section

When NOT to use:

• Simple append to end of note (use update_note with merge_strategy='append')

• Replacing entire note content (use update_note)

• Creating a new note (use create_note)

Section identification:

• Sections are identified by markdown headings (# ## ### etc.)

• Match is case-insensitive

• First matching heading is used if duplicates exist

• Section includes content until next heading of same/higher level

Operations:

• insert_after: Add content immediately after the section heading

• insert_before: Add content immediately before the section heading

• replace: Replace entire section including the heading

• append_to_section: Add content at the end of the section

Returns: Edit status including whether section was found or created

Delete a note from the vault permanently.

When to use:

• Removing outdated or duplicate notes

• Cleaning up temporary drafts

• Part of a move operation (delete after successful copy)

When NOT to use:

• Archiving (use move_note to Archive folder instead)

• Temporary removal (no undo available)

⚠️ WARNING: This operation cannot be undone. The note will be permanently deleted.

Returns: Deletion confirmation with the path of the deleted note

Search for notes by filename or content, with smart ranking.

DEFAULT BEHAVIOR (NEW): Searches BOTH note filenames AND content automatically. Filename matches are ranked higher than content matches for better discovery.

When to use:

• Finding a note when you know part of its name (just type the name)

• Finding notes containing specific content

• Locating notes with specific tags

• Searching within specific folders

• Finding notes by frontmatter properties

Search modes:

• Default: searches BOTH filenames and content (filename matches ranked higher) Example: "tag refactor" finds "Obsidian Tag Refactor.md" AND notes mentioning "tag refactor"

• "path:text" - searches ONLY in filenames/paths

• "tag:tagname" - searches by tag (supports hierarchical tags)

• "property:name:value" - searches by frontmatter properties

Examples:

• Find a note by name: "Project Tracker" (will find "Project Tracker.md" first)

• Search content only: Use explicit path: prefix to exclude: "path:Project"

• Find by tag: "tag:important" or "tag:project/web"

• Find by property: "property:status:active"

Tag search supports hierarchical tags:

• "tag:project" finds all project-related tags including project/web, project/mobile

• "tag:web" finds any tag ending with "web" like project/web, design/web

When NOT to use:

• Searching by date (use search_by_date instead)

• Listing all notes (use list_notes for better performance)

• Reading a specific note when you know the exact path (use read_note directly)

Returns: Search results with matched notes, relevance scores, and context. Filename matches have higher scores than content matches. Response includes match_type field: "filename" or "content".

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

Search for notes using regular expressions for advanced pattern matching.

When to use:

• Finding complex patterns (URLs, code syntax, structured data)

• Searching with wildcards and special characters

• Case-sensitive or multi-line pattern matching

• Finding TODO/FIXME comments with context

When NOT to use:

• Simple text search (use search_notes instead)

• Searching by tags or properties (use dedicated tools)

Common patterns:

• URLs: r"https?://[^\s]+"

• Email: r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}"

• TODO comments: r"(TODO|FIXME)\s*:.*"

• Markdown headers: r"^#{1,6}\s+.*"

• Code blocks: r"\w*\n[\s\S]*?"

Returns: Notes containing regex matches with match details and context

Search for notes by their frontmatter property values.

When to use:

• Finding notes with specific metadata (status, priority, etc.)

• Filtering by numeric properties (rating > 4, priority <= 2)

• Filtering by date properties (deadline < "2024-12-31")

• Searching within array/list properties (tags, aliases, categories)

• Checking which notes have certain properties defined

• Building database-like queries on your notes

Property types supported:

• Text/String: Exact match or contains

• Numbers: Comparison operators work numerically

• Dates: ISO format (YYYY-MM-DD) with intelligent comparison

• Arrays/Lists: Searches within list items, comparisons use list length

• Legacy properties: Automatically handles tag→tags, alias→aliases migrations

When NOT to use:

• Content search (use search_notes instead)

• Tag search (use search_notes with tag: prefix)

• Path/filename search (use search_notes with path: prefix)

Examples:

• Find active projects: property_name="status", value="active"

• Find high priority: property_name="priority", operator=">", value="2"

• Find notes with deadlines: property_name="deadline", operator="exists"

• Find notes by author: property_name="author", operator="contains", value="john"

• Find notes with tag in list: property_name="tags", value="project"

• Find past deadlines: property_name="due_date", operator="<", value="2024-01-01"

Returns: Notes matching the property criteria with values displayed

List notes in the vault or a specific directory.

When to use:

• Getting an overview of vault structure

• Finding notes in a specific folder

• Checking what notes exist before bulk operations

• Understanding vault organization

When NOT to use:

• Searching for specific content (use search_notes)

• Finding notes by properties (use search_by_property)

• Just counting notes (this loads full paths)

Performance notes:

• Fast for directories with <100 notes

• May be slower for large vaults (1000+ notes) with recursive=True

Returns: Hierarchical structure of notes with paths and folder organization

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

Move a note to a new location, optionally with a new name.

When to use:

• Reorganizing notes into different folders

• Moving AND renaming in one operation

• Archiving completed projects

• Consolidating scattered notes

When NOT to use:

• Just renaming within same folder (use rename_note for clarity)

• Copying notes (use read_note + create_note instead)

• Moving entire folders (use move_folder)

Link updating:

• Automatically detects if filename changes during move

• Updates all [[wiki-style links]] only when name changes

• Preserves link aliases and formatting

• No updates needed for simple folder moves (links work by name)

Returns: Move confirmation with path changes and link update details

Rename a note and automatically update all references to it.

When to use:

• Changing a note's title to better reflect its content

• Fixing typos in note names

• Standardizing naming conventions

• Updating temporary names to permanent ones

When NOT to use:

• Moving notes to different folders (use move_note)

• Creating a copy with new name (use read_note + create_note)

Important:

• Can only rename within the same directory

• Automatically updates all [[wiki-style links]] throughout vault

• Preserves link aliases like [[old name|display text]]

• Shows which notes were updated for transparency

Returns: Rename confirmation with link update details

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., "Research/Studies/2024")

• 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, "Research/Studies/2024" will create Research, Research/Studies, and Research/Studies/2024 if they don't exist.

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

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

Add tags to a note's frontmatter.

When to use:

• Organizing notes with tags

• Creating hierarchical tag structures (e.g., project/web, work/meetings/standup)

• Bulk tagging operations

• Adding metadata for search

Tag format:

• Simple tags: "project", "urgent"

• Hierarchical tags: "project/web", "work/meetings/standup"

• Tags are automatically added without duplicates

When NOT to use:

• Adding tags in note content (use update_note)

• Replacing all tags (use update_tags with merge=False)

Returns: Updated tag list for the note

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

Remove specific tags from a note's frontmatter.

When to use:

• Cleaning up outdated tags

• Removing temporary tags (like 'draft' or 'review')

• Tag maintenance and reorganization

• After completing tagged tasks

When NOT to use:

• Removing all tags (use update_tags with empty list)

• Replacing tags (use update_tags with merge=False)

Note: Only removes exact matches. To remove all subtags of a hierarchical tag, list them explicitly or use update_tags.

Returns: Updated tag list after removal, with count of removed tags

Get metadata and statistics about a note without reading its content.

When to use:

• Checking note properties quickly (tags, dates, size)

• Getting frontmatter without loading content

• Gathering statistics (word count, link count)

• Verifying note exists and getting basic info

• Batch processing note metadata

When NOT to use:

• Reading note content (use read_note)

• Searching for notes (use search tools)

• Modifying metadata (use specific update tools)

Returns: Note metadata including path, existence, dates, size, frontmatter properties, and statistics (word count, link count, tag count, image presence)

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

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

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

When to use:

• After renaming or deleting notes

• Regular vault maintenance

• Before reorganizing folder structure

• Cleaning up after imports

• Checking links in a specific note

When NOT to use:

• Just getting outgoing links without needing broken status (use get_outgoing_links)

• Finding backlinks (use get_backlinks)

Returns: All broken links found in the specified scope

Find orphaned notes that may need organization or cleanup.

When to use:

• Regular vault maintenance and cleanup

• Finding forgotten or disconnected notes

• Identifying notes that need better organization

• Preparing for vault reorganization

• Finding candidates for archival or deletion

Orphan types explained:

• no_backlinks: Notes with no incoming links (most common definition)

• no_links: Notes with no incoming OR outgoing links (completely isolated)

• no_tags: Notes without any tags (untagged content)

• no_metadata: Notes with minimal/no frontmatter properties

• isolated: Notes with no links AND no tags (truly disconnected)

Default exclusions:

• Templates folder (usually contains reference notes)

• Archive folder (already organized)

• Daily folder (daily notes often standalone)

When NOT to use:

• Finding specific notes (use search_notes)

• Getting all notes in a folder (use list_notes)

• Finding notes by content (use search tools)

Performance note:

• Scans entire vault and checks links/metadata for each note

• For vaults >1000 notes, this may take 10-30 seconds

Returns: List of orphaned notes with paths, reasons, and metadata. Results are sorted by modification date (oldest first).

Example response: { "count": 23, "orphaned_notes": [ { "path": "Random Thoughts/Old Idea.md", "reason": "No incoming links", "modified": "2023-06-15T10:30:00Z", "size": 245, "word_count": 42 } ], "stats": { "total_notes_scanned": 500, "excluded_folders": ["Templates", "Archive", "Daily"], "orphan_type": "no_backlinks" } }

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')

• Understanding hierarchical tag structures in your vault

• Finding all files that use a specific tag (with include_files=true)

Hierarchical tags:

• Lists both parent and full hierarchical paths (e.g., both "project" and "project/web")

• Shows how nested tags are organized in your vault

• Helps identify opportunities for better tag organization

File paths (with include_files=true):

• Returns a list of all file paths that contain each tag

• Useful for bulk operations on files with specific tags

• Paths are relative to vault root

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

• include_files=true adds minimal overhead

Returns: All unique tags with optional usage counts and file paths

Batch update properties across multiple notes.

When to use:

• Updating metadata across many notes (status, priority, etc.)

• Bulk tag operations (add/remove tags from multiple notes)

• Archiving projects (set archived=true, add year property)

• Cleaning up properties (remove outdated fields)

• Normalizing metadata across your vault

Search criteria options:

• query: Use search syntax (tag:project, folder:Archive, property:status:active)

• folder: Process all notes in a folder (with optional recursive flag)

• files: Explicit list of file paths

Property operations:

• Add/update any frontmatter property

• Remove properties by name

• Special handling for tags (add/remove with deduplication)

• Remove inline #tags from note body (optional)

Examples:

• Archive completed projects: query="tag:project status:completed", property_updates={"archived": true, "year": 2024}

• Clean up draft tags: query="tag:draft", remove_tags=["draft"], remove_inline_tags=true

• Update all notes in folder: folder="Projects/2023", property_updates={"year": 2023}

When NOT to use:

• Single note updates (use update_note, add_tags, etc.)

• Complex content changes (this only updates frontmatter)

Returns: { "total_notes": 10, # Total notes found matching criteria "updated": 8, # Successfully updated notes "failed": 2, # Failed updates "details": [...], # List of changes per note "errors": [...] # List of errors with paths and reasons }

Read an image file from the Obsidian vault for analysis.

When to use:

• Analyzing specific image files from the vault

• Examining standalone images (not embedded in notes)

• Processing images for detailed analysis

When NOT to use:

• Getting images embedded in notes (use view_note_images instead)

• Searching for images (use list_notes with appropriate filters)

Returns: Image object that Claude can analyze and describe

Extract and analyze images embedded in a note.

When to use:

• Analyzing images referenced in a note's markdown content

• Examining visual content within notes (screenshots, diagrams, etc.)

• Extracting specific images from notes for analysis

When NOT to use:

• Reading standalone image files (use read_image instead)

• Getting note content without images (use read_note instead)

Returns: List of Image objects that Claude can analyze and describe