| read_note_tool | 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_note_tool | 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: Returns:
Created note information with path and metadata |
| update_note_tool | 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_note_section_tool | 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_note_tool | 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: ⚠️ WARNING: This operation cannot be undone. The note will be permanently deleted. Returns:
Deletion confirmation with the path of the deleted note |
| search_notes_tool | 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_by_date_tool | 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: Returns:
Notes matching the date criteria with paths and timestamps |
| search_by_regex_tool | 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: 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_by_property_tool | 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_tool | 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: Returns:
Hierarchical structure of notes with paths and folder organization |
| list_folders_tool | 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: Returns:
Folder structure with paths and names |
| move_note_tool | 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_note_tool | 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: 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_folder_tool | 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: 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_folder_tool | 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: Returns:
Move status with count of notes and folders moved |
| add_tags_tool | 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: Returns:
Updated tag list for the note |
| update_tags_tool | 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: Returns:
Previous tags, new tags, and operation performed |
| remove_tags_tool | 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: 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_note_info_tool | 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) |
| get_backlinks_tool | 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: 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 |
| get_outgoing_links_tool | 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: Returns:
All outgoing links with their types and optional validity status |
| find_broken_links_tool | 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: Returns:
All broken links found in the specified scope |
| find_orphaned_notes_tool | 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_tags_tool | 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: 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_tool | 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_image_tool | 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: Returns:
Image object that Claude can analyze and describe |
| view_note_images_tool | 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: Returns:
List of Image objects that Claude can analyze and describe |
