MCP tool reference

List the vault as a tree of folders and notes. Omit `path` for the whole vault; pass a folder path to scope the tree to that subtree, and `depth` to limit how far down it goes.

List the direct children of one folder (omit `path` for the vault root). Prefer this over list_tree when you only need one level — it never loads note bodies and never walks the whole vault. `depth` above 1 includes deeper descendants.

Report whether a vault path is a note or a folder, with its id and canonical stored path. Use it instead of guessing a kind — note paths are stored without the `.md` extension. A note also reports a `docKind`: `canvas` means it holds a drawing, which the editing tools refuse to write text into.

Read a note by vault-relative path. Returns id, path, kind, markdown content, and timestamps. A note whose kind is `canvas` holds a drawing rather than text, and its content is always empty.

Read a note by stable document UUID. Returns path, kind, markdown content, and timestamps. A note whose kind is `canvas` holds a drawing rather than text, and its content is always empty.

Search the vault. Note hits come back in `hits`, carrying the note path and a 1-based line number, or line 0 when the query matched the note's name rather than its body. Folder hits come back separately in `folders`, and only when `kinds` asks for them. `matchPath` widens matching to the full vault path, so a query of 'projects' also finds notes inside a folder of that name.

List saved version metadata for a note by vault-relative path.

Read the archived markdown content for a saved note version by version UUID.

Restore a saved note version by version UUID. The restored content becomes current and archives the previous current content.

Create a markdown note at the given vault-relative path, optionally with initial content. Missing parent folders are created. Fails when the path is taken unless `ifExists` is 'skip'.

Overwrite the markdown body of a note, creating it (and any missing parent folders) when it does not exist. A previous version is archived only when the content actually changed.

Append text to the end of an existing note, atomically. Prefer this over reading a note and writing it back: a concurrent edit cannot be lost. By default a newline is inserted first when the note does not already end with one. Empty text is a no-op and does not archive a version.

Find and replace inside one note, server-side. `mode` 'literal' treats `find` as plain text; 'regex' matches each line separately, so `^` and `$` anchor per line and a pattern cannot span a newline. `dryRun` reports what would change without writing. A run that changes nothing leaves the note, and its modified time, untouched.

Delete a note at the given vault path.

Create a spreadsheet at the given vault-relative path, optionally with initial cells. Missing parent folders are created. Fails when the path is taken unless `ifExists` is 'skip'.

Read a spreadsheet. Returns `tsv`, a tab-separated rendering with one line per row, and `cells`, the raw text of every filled cell keyed by A1 reference. Formulas are returned as written, not as their results.

Write individual cells, leaving every other cell as it is. Send an empty string to clear a cell. The sheet grows to cover any cell written past its current extent. Formatting already on a cell is kept.

Replace every cell in a spreadsheet with the given set, discarding anything not listed. Use `set_cells` to change part of a sheet; this is for rewriting one wholesale. Cell formatting is discarded with the old cells.

Create a folder at the given vault path, creating any missing parents. Fails when the path is taken unless `ifExists` is 'skip'.

Move a note or folder to an explicit destination path — re-parent, rename, or both in one call. When `to` names an existing folder the entry moves into it keeping its own name (as `mv` does). Missing parent folders are created. `kind` is inferred unless given.

Rename a note or folder, keeping its parent. `kind` is inferred when omitted. Prefer move_entry, which can rename and re-parent in one call.

Move a note or folder under a new parent folder, keeping its name. Omit `toParent` for the vault root. Prefer move_entry, which takes a full destination path.

Delete a note or folder at the given vault path, with everything under it. `kind` is inferred when omitted; a path claimed by both a note and a folder is refused rather than guessed. `recursive` defaults to true; pass false to refuse a folder instead, which lets a client enforce an `rm -r` style guard without a separate lookup.

List the tag library with how many notes and folders carry each tag. A tag with zero uses is normal: tags outlive their assignments and are only removed by delete_tag.

Takes no parameters.

Read the tags on one note or folder, by vault path.

Create a tag in the library without attaching it to anything. Only needed to pick a colour up front — set_tags and add_tags create missing tags on their own. Fails when the name is taken, ignoring case.

Rename a tag, change its colour, or both. Renaming keeps every assignment. Pass color: null to clear the colour; omit the field to leave it alone.

Remove a tag from the library. Allowed while it is in use: every note and folder carrying it loses it. This is the only thing that removes a tag — nothing prunes unused ones.

Replace the whole tag set on one note or folder. Pass an empty array to clear it. Prefer add_tags or remove_tags when changing one tag, since those cannot clobber a concurrent edit to another.

Add tags to a note or folder, leaving the ones already on it alone. Names that do not exist yet are created.

Take tags off a note or folder. The tags stay in the library; only the assignments go. Names not on the entry are ignored.

Move or rename up to 100 notes and folders in a single transaction — either all of them move or none do. Each entry gives its own destination, so one call can re-parent some entries and rename others. When a `to` names an existing folder the entry moves into it keeping its own name. Prefer this over repeating move_entry: it is atomic, and it counts as one request against the rate limit.

Delete up to 100 notes and folders in a single transaction — either all of them go or none do. A folder takes everything under it. Naming both a folder and something inside it is fine: the inner path is covered by the folder and is not reported separately. A path claimed by both a note and a folder is refused rather than guessed. `recursive` defaults to true and applies to the whole batch; pass false to refuse the batch if any entry is a folder.