Skip to content

CLI Reference ​

A flat reference for every memrynote command, flag, and positional argument. For a prose walkthrough, see Command Line.

Synopsis ​

bash
memrynote [--vault <path>] [--json] <command> [subcommand] [args] [flags]

The 26 top-level commands are listed in the usage error when you run memrynote with no arguments:

vault | notes | folders | properties | folder-view | tasks | projects |
inbox | journal | tags | settings | locale | reminders | templates |
bookmarks | saved-filters | calendar | sync | agent | graph | search |
canvas | home-pages | icons | import | readwise

Global flags ​

FlagTypeDescription
--vault <path>pathOverride the default vault for this call.
--jsonbooleanEmit machine-readable JSON instead of a human-formatted block.

The CLI reads the default vault from your desktop Settings → Command Line → Default vault. With multiple vaults configured, you must pick one either via memrynote vault use <name> or --vault <path> per call.

Output conventions ​

Without --json, primitives print as themselves and objects/arrays pretty-print as JSON with 2-space indentation. With --json, the underlying MemryApp.* method's return value is emitted on a single line. Delete commands return { "success": boolean }; bulk operations typically return { "count": number }.

Commands that change or remove data are marked destructive below. Every destructive command requires --yes and exits non-zero without it.


vault ​

memrynote vault <list|current|use|remove|init|status|open|config|update-config|reindex|set-icon|activity|locks> [args]

list ​

Lists known vaults from the desktop app's registry.

FlagTypeRequiredDescription
none
bash
memrynote vault list

current ​

Prints the active vault (from --vault or the configured default).

bash
memrynote --json vault current

use ​

Sets the default vault for future CLI calls.

PositionalDescription
<vault-name-or-path>A name from vault list or an absolute path.
bash
memrynote vault use work

init ​

Idempotently creates .memry/ folder layout and the local databases if missing.

bash
memrynote vault init

status ​

Returns vault metadata: path, version, sizes, last opened.

bash
memrynote vault status

open ​

Alias of status.

config ​

Returns the vault's editable config.

bash
memrynote vault config

update-config ​

Merges a JSON object into the vault config.

PositionalDescription
<json>Partial config object.
bash
memrynote vault update-config '{"excludePatterns":[".git","tmp"]}'

reindex ​

Rebuilds the full-text search index (fts_notes, fts_tasks, fts_inbox) from scratch, as the desktop's "Rebuild search index" does. Notes come from the files of notes the desktop has already indexed, so a note created only through the CLI is found by the substring scan until the desktop opens the vault. Returns { notes, tasks, inbox, skipped, durationMs }. skipped counts indexed notes whose file could not be read. Safe to repeat. It changes no vault files.

bash
memrynote vault reindex

set-icon ​

Sets the vault's icon, or resets it to the default. The desktop syncs the change to your account the next time it runs.

PositionalDescription
<icon>icon:<Name> (for example icon:Star), a single emoji, or null to reset.
bash
memrynote vault set-icon icon:Star

activity ​

Reads or clears the vault activity log (.memry/activity.jsonl): files picked up, removed, skipped or failed, and importer runs. The log stays on this device.

bash
memrynote vault activity list [--problems] [--limit <n>]
memrynote vault activity clear --yes

list returns the newest entries first (default 200, at most 1000). --problems keeps skipped and failed entries and summaries that count either. clear needs --yes.

locks ​

bash
memrynote vault locks list

Returns { notes: [<note id>], folders: [<folder path>] } for the read-only locks on this device. vault locks set exits with an error: locking protects the files on disk and syncs the lock, which only the desktop app does.

remove (destructive) ​

Takes a vault off the list of known vaults. Its files stay on disk. Needs the desktop app command (Settings → Command Line) and --yes.

PositionalDescription
<vault-name-or-path>A name from vault list or an absolute path.
bash
memrynote vault remove work --yes

notes ​

memrynote notes <subcommand> [args]

create ​

PositionalDescription
<title>New note title.
FlagTypeDescription
--content <text>stringInitial body. Defaults to empty.
--folder <path>stringTarget folder, vault-relative. Without it the note lands in the configured default note folder.
--tag <name>repeatableTag to add. Pass multiple times.
--properties <json>JSON objectInitial frontmatter.
bash
memrynote notes create "Draft" --content "First line" --folder Projects --tag writing

list ​

FlagTypeDescription
--folder <path>stringRestrict to one folder (vault-relative).
--limit <n>numberMax rows. Default 100.
bash
memrynote notes list --folder Projects --limit 20

get ​

PositionalDescription
<id-or-path>Note id (e.g. note_abc123) or vault path.
bash
memrynote notes get note_abc123

exists ​

Returns { exists: boolean }.

PositionalDescription
<id-or-path>Note id or path.

preview ​

Resolves a wiki-link title and returns a content preview.

PositionalDescription
<title>Note title.

resolve ​

Resolves a wiki-link title to a concrete note record (no body). A note's aliases resolve too; a title always wins over an alias. Pass several titles to resolve them in one call: the output is then an object keyed by title, each value { "id", "path" } or null.

PositionalDescription
<title>…One or more titles, aliases, or Folder/Note paths.

Returns inbound and outbound links for a note.

PositionalDescription
<id-or-path>Note id or path.

update ​

PositionalDescription
<id-or-path>Note to modify.
FlagTypeDescription
--title <text>stringNew title.
--content <text>stringReplace body.
--append <text>stringAppend to body.
--tag <name>repeatableReplace tag set. Omit to leave untouched.
--properties <json>JSON objectReplace frontmatter.
bash
memrynote notes update note_abc123 --append "More text" --properties '{"status":"active"}'

rename ​

Renames the note and rewrites every inbound [[Old Title]] wiki-link vault-wide — headings kept, aliases untouched, case-insensitive — the same way the desktop app does.

PositionalDescription
<id-or-path>Note.
<new-title>New title.

move ​

PositionalDescription
<id-or-path>Note.
<folder>Destination folder path, vault-relative. '' = the vault root.

set-local-only ​

PositionalDescription
<id-or-path>Note.
<true/false>Whether to exclude from sync.

local-only-count ​

Returns the count of notes flagged local-only.

delete (destructive) ​

Requires --yes. Returns { success: boolean }.

PositionalDescription
<id-or-path>Note.
bash
memrynote notes delete note_abc123 --yes

attach ​

Copies the file into the vault, appends a desktop-style embed to the note body (inline image or clickable file block), and queues the upload for sync.

PositionalDescription
<note-id>Note.
<file-path>Absolute path to copy in as an attachment.

Two other sources replace <file-path>:

FlagDescription
--existing <owner-note-id>/<filename>Embeds an attachment another note already stores. Nothing is copied or uploaded; the ref points at the owner's file.
--url <url>Downloads a public http(s) image (jpeg, png, webp, gif, up to 10 MB) into the note's own attachments folder and embeds it.

attachments ​

Lists attachments for a note. With --all it lists every attachment in the vault instead, newest first, each with its owning note (ownerNoteId, ownerNoteTitle, filename, displayName, size, mimeType, type, modifiedAt). <note-id> is not needed with --all.

PositionalDescription
<note-id>Note.
FlagTypeDescription
--allboolList the whole vault's attachments.

delete-attachment (destructive) ​

Requires --yes.

PositionalDescription
<note-id>Note.
<attachment-id>Attachment.

import-files ​

PositionalDescription
<paths...>Files or folders to import.
FlagTypeDescription
--folder <path>stringTarget folder.

export-html ​

PositionalDescription
<note-id>Note.
<output-path>Destination file.
FlagTypeDescription
--no-metadatabooleanOmit frontmatter.
--include-metadata <true/false>booleanForce include. Default true.
--include-task-markersbooleanKeep each task's {task:<id>}. Left out by default.

export-pdf ​

Same positionals as export-html plus:

FlagTypeDescription
--no-metadatabooleanOmit frontmatter.
--include-metadata <true/false>booleanForce include. Default true.
--include-task-markersbooleanKeep each task's {task:<id>}. Left out by default.
--page-size <name>stringe.g. A4, Letter.

export-markdown ​

PositionalDescription
<note-id>Note.
<output-path>Destination .md file.

snapshot ​

Creates a manual version snapshot.

PositionalDescription
<note-id>Note.
FlagTypeDescription
--reason <label>stringSnapshot label. Default manual.
--forcebooleanTake a snapshot even if content hasn't changed.

versions ​

Lists the version history of a note.

PositionalDescription
<note-id>Note.
FlagTypeDescription
--limit <n>numberDefault 50.

version ​

Returns one snapshot.

PositionalDescription
<snapshot-id>Snapshot.

restore-version ​

Restores a note to a snapshot.

delete-version (destructive) ​

Requires --yes.

aliases ​

Shows or edits a note's other names (the aliases frontmatter list). Edits are deltas: removals by name (case and spacing insensitive) first, then additions. Names are trimmed, deduplicated, never equal to the title, and capped at 32. The output is { "aliases": [...] }.

PositionalDescription
<id-or-path>Note id or path.
FlagTypeDescription
--add <name>stringAdd an alias. Repeatable.
--remove <name>stringRemove an alias. Repeatable.
--set <name>stringReplace the list. Repeatable; use alone.
--clearboolRemove every alias.
bash
memrynote notes aliases note_abc123 --add "Standup" --add "Sync"

apply-template ​

Replaces a note's body with a template's content ( is filled in). By default it also adds the template's tags without dropping the note's own, merges its properties (the note's values win), and leaves the title alone. Custom templates only; the built-in templates exist in the desktop app.

PositionalDescription
<id-or-path>Note.
<template-id>Template.
FlagTypeDescription
--body-onlyboolReplace the body only; keep tags and properties.

unlinked-mentions ​

Lists notes that spell this note's title or an alias as plain text without linking to it. Notes that already link to it are left out. Each entry has sourceId, sourcePath, sourceTitle, and contexts[] (snippet, linkStart, linkEnd); a context's position in the list is its --ordinal.

PositionalDescription
<id-or-path>Note.

Turns one unlinked mention into a wiki link: [[Title|text]], or [[Title]] when the text already spells the title. The output is { "linked": true|false }; false means that mention no longer exists.

PositionalDescription
<source-id>Note holding the mention.
<target-id>Note the link should point to.
FlagTypeDescription
--ordinal <n>numberWhich mention in the source (default 0).

carried-tasks ​

Lists the tasks a note (or every note under a folder) carries as - [ ] Title {task:<id>} lines, so you know what a delete would orphan. A task also linked to a note that stays is left out. The output is { "taskIds": [...] }. This only reads; it deletes nothing.

PositionalDescription
<note-id>…Notes.
FlagTypeDescription
--folder <path>stringInclude every note under it. Repeatable.

similar / suggest-tags ​

Desktop shows similar notes and tag suggestions from its on-device embeddings index. The CLI cannot read that index, so both commands exit non-zero with a message saying so.

positions ​

Prints the manual sidebar order as { "positions": { "<path>": <n> } }.

FlagTypeDescription
--folder <path>stringOnly that folder (use . for the vault root).

reorder ​

Sets the manual sidebar order of notes in one folder, first note first. Every path must be an existing note directly inside that folder.

PositionalDescription
<note-path>…Vault-relative note paths, in order.
FlagTypeDescription
--folder <path>stringThe folder. Omit for the vault root.

read-lines ​

Reads a window of lines from a note or any vault file without loading it whole, for files too large to open. Lines are 0-based like the desktop large-file viewer; a line over 64 KB is cut and listed in truncated. The output is { startLine, lines, truncated, endOfFile }.

PositionalDescription
<id-or-path>Note id, or a path inside the vault.
FlagTypeDescription
--from <n>numberFirst line (default 0).
--count <n>numberLines to read, 1 to 2000 (default 200).

grep ​

Finds a literal text (ASCII case-insensitive, one line at a time) in a note or vault file, streaming it. The output is { status, query, hits[], total, limited } where each hit is { line, ordinal } and hits is capped at 2000 while total counts every match.

PositionalDescription
<id-or-path>Note id, or a path inside the vault.
<text>Text to find, up to 200 characters.

attachment-rename ​

Renames an attachment the note owns. The id prefix and the extension stay; the name part is replaced (a clash gets -2, -3). The note body's embed and the file block's name are updated. Other notes that borrowed the file through --existing keep the old ref until it is repaired. The output is { storedFilename, url, name }.

PositionalDescription
<note-id>Owning note.
<filename>Stored filename, as notes attachments shows it.
<new-name>…New name. Words are joined with a space.

folders ​

Folder paths are vault-relative: the configured default note folder is only where an unplaced note lands, never a root the CLI resolves folders under.

list ​

bash
memrynote folders list

create ​

PositionalDescription
<path>Folder path.

rename ​

PositionalDescription
<old-path>Existing folder.
<new-path>New path.

delete (destructive) ​

Requires --yes.

PositionalDescription
<path>Folder.

template ​

Shows or sets the folder's default template for new notes. Showing resolves the way desktop does: the nearest folder up the tree with a template wins, and inherit: false in a .folder.md stops the climb. Setting keeps the folder's icon and views. The output is { "folder", "template" }.

PositionalDescription
<path>Folder (use . for the vault root).
<template-id>Optional. Sets this template; omit to show it.
FlagTypeDescription
--clearboolRemove the folder's template.

properties ​

get ​

Returns custom properties for any entity (note, task, etc.) that supports them.

PositionalDescription
<entity-id>Entity id.

set ​

PositionalDescription
<entity-id>Entity.
<json>Properties JSON object.

rename ​

Renames a property key on one entity.

PositionalDescription
<entity-id>Entity.
<old-key>Existing key.
<new-key>New key.

definitions ​

Lists workspace-wide property definitions. select, multiselect, status, date, and project definitions are mirrored into .memry/properties.md so the desktop app and other devices pick them up; relation definitions stay DB-only by design.

define ​

PositionalDescription
<name>Definition name.
<type>e.g. text, number, select, date.
FlagTypeDescription
--options <json>anyType-specific options (e.g. select choices).
--default <json>anyDefault value.
--color <name>stringUI color.

update-definition ​

PositionalDescription
<name>Definition.
FlagTypeDescription
--type <name>stringNew type.
--options <json>anyNew options.
--default <json>anyNew default.
--color <name>stringNew color.

delete-definition (destructive) ​

Requires --yes.

ensure ​

Makes sure a definition of the given type exists. An existing name of another type takes the new type and keeps its colour.

PositionalDescription
<name>Property.
<type>Type.

option-add ​

Adds a choice to a select, multiselect, or status property. A missing property becomes a select. A choice that exists is left alone.

PositionalDescription
<name>Property.
<value>New choice.
FlagTypeDescription
--color <name>stringChoice colour (default stone).
--category <key>stringStatus category: todo, in_progress, or done (status only).

option-remove (destructive) ​

Removes a choice from the definition. Notes that hold the value keep it. Requires --yes.

PositionalDescription
<name>Property.
<value>Choice.

option-rename ​

Renames a choice in the definition only, like desktop; notes that already hold the old value are not rewritten.

PositionalDescription
<name>Property.
<old-value>Existing choice.
<new-value>New name.

option-color ​

PositionalDescription
<name>Property.
<value>Choice.
<color>New colour.

merge ​

Patches properties on a note or journal: only the given keys change, and a null value removes its key. The output is { "properties", "removed" }. set replaces the whole set; merge does not.

PositionalDescription
<entity-id>Note or journal id.
<json>JSON object of keys.

resolve-refs ​

Resolves relation URIs (memry://note/<id>, task, event, external-event, canvas, journal/<date>) to title and existence, in input order. A malformed or missing target comes back with exists: false instead of failing.

PositionalDescription
<uri>…One or more relation URIs.

calendar-names ​

Lists the date properties set to show on the calendar.

calendar-visibility ​

Shows or hides a date property on the calendar. Turning it off removes a definition that exists only to carry the flag; one with a colour or default stays.

PositionalDescription
<name>Date property.
<show>true or false.

folder-view ​

Per-folder view configuration (sort, filters, custom views).

config ​

PositionalDescription
<folder-path>Folder.

set-config ​

PositionalDescription
<folder-path>Folder.
<json>Folder view config object.

views ​

Lists named views for a folder.

set-view ​

PositionalDescription
<folder-path>Folder.
<view-json>View definition.

delete-view ​

PositionalDescription
<folder-path>Folder.
<view-id>View.

list ​

Notes in the folder enriched with their visible properties.

PositionalDescription
<folder-path>Folder.
FlagTypeDescription
--limit <n>numberDefault 100.
--offset <n>numberDefault 0.

properties ​

Lists properties available in this folder.

suggestions ​

Suggests folders for a note.

PositionalDescription
<note-id>Note.

exists ​

Returns { exists: boolean } for a folder path.


tasks ​

create ​

PositionalDescription
<title>Task title.
FlagTypeDescription
--description <text>stringBody.
--project <id>stringProject id.
--status <id/null>stringStatus id; null for inbox.
--parent <id/null>stringParent task id.
--due <YYYY-MM-DD>stringDue date.
--due-time <HH:MM>stringDue time.
--start <YYYY-MM-DD>stringStart date.
--repeat <json>JSONRecurrence config.
--repeat-from <due/completion>stringRecurrence anchor.
--source-note <id>stringOriginating note.
--priority <n>numberDefault 0.
--tag <name>repeatableTag.
--link-note <id>repeatableLinked note.
--link-canvas <id>repeatableLinked canvas.
--duration <minutes>numberDuration in minutes. A positive whole number; null clears it on update.
--field <name=value>repeatableCustom field value. The value is read as JSON when it parses (3, true, ["a","b"]) and as text otherwise. On update, name=null removes the field.

Task records now include fields, an object of field values by name.

bash
memrynote tasks create "Plan trip" --duration 45 --field effort=3 --field owner=Kaan

list ​

FlagTypeDescription
--completedbooleanInclude completed.
--archivedbooleanInclude archived.
--project <id>stringFilter by project.
--status <id/null>stringFilter by status.
--parent <id/null>stringFilter by parent.
--due-before <date>stringDue strictly before.
--due-after <date>stringDue strictly after.
--tag <name>repeatableTag filter.
--search <text>stringText search.
--sort-by <field>stringSort key.
--sort-order <asc/desc>stringSort direction.
--limit <n>numberPagination.
--offset <n>numberPagination.
bash
memrynote tasks list --project proj_1 --due-before 2026-01-01 --sort-by due --sort-order asc

get ​

PositionalDescription
<id>Task id.

update ​

Positional <id>. Same flags as create; only specified flags are written.

done / complete ​

Marks a task complete.

PositionalDescription
<id>Task id.

reopen ​

Reopens a completed task. Same effect as the desktop's uncomplete: it clears completedAt and leaves the task's status alone.

archive / unarchive ​

Toggles the archive flag.

move ​

PositionalDescription
<id>Task.
FlagTypeDescription
--project <id>stringDestination project.
--status <id/null>stringDestination status.
--parent <id/null>stringNew parent.
--position <n>numberPosition within the status column.

get-subtasks ​

PositionalDescription
<id>Parent task.

get-linked-tasks ​

PositionalDescription
<note-id>Note whose linked tasks to return.

today ​

FlagTypeDescription
--date <YYYY-MM-DD>stringOverride "today".

upcoming ​

FlagTypeDescription
--days <n>numberWindow. Default 7.
--from <YYYY-MM-DD>stringWindow start.

overdue ​

FlagTypeDescription
--date <YYYY-MM-DD>stringReference date.

stats ​

FlagTypeDescription
--date <YYYY-MM-DD>stringReference date.

tags ​

Returns the set of tags used on tasks.

convert-to-subtask ​

PositionalDescription
<task-id>Task to demote.
<parent-id>New parent.

convert-to-task ​

Promotes a subtask back to a top-level task.

PositionalDescription
<id>Task.

duplicate ​

PositionalDescription
<id>Source task.

bulk-done / bulk-complete ​

PositionalDescription
<id...>Task ids.

bulk-archive ​

PositionalDescription
<id...>Task ids.

bulk-move ​

PositionalDescription
<id...>Task ids.
FlagTypeRequiredDescription
--project <id>stringyesDestination project.

bulk-delete (destructive) ​

Requires --yes. Deletes each task's subtasks with it, like desktop. Pass --keep-subtasks to keep them instead; see delete. Put the flags after the ids.

FlagTypeDescription
--keep-subtasksbooleanMove each task's direct subtasks up to its parent instead of deleting them.

Output: { "count": <requested tasks that existed> }.

reorder ​

Reorders tasks within their list.

PositionalDescription
<id...>Task ids in desired order.
FlagTypeDescription
--position <n>repeatableOne per id, parallel to positional order.

delete (destructive) ​

Requires --yes. Deletes the task and its whole subtask branch, deepest first, so no subtask keeps a parent that is gone. Each removed task queues its own sync delete, which the desktop app turns into a tombstone the next time sync starts.

PositionalDescription
<id>Task id.
FlagTypeDescription
--keep-subtasksbooleanKeep the subtasks: each direct subtask moves up to the deleted task's own parent (top level when it had none), as in the desktop's "keep subtasks" choice.

Put the flags after the id (tasks delete <id> --yes --keep-subtasks).

activity ​

Task audit log, newest first: what changed, when, and whether the change was made on this device. Shows the entries the desktop app and sync have written. The CLI does not write activity entries itself.

PositionalDescription
<id>Task id.
FlagTypeDescription
--limit <n>numberPage size, default 50.
--offset <n>numberSkip entries.
--action <name>repeatableOnly these actions: created, updated, completed, uncompleted, moved, deleted, superseded.

Output: { "entries": [...], "total": n, "hasMore": bool }. Status, project and parent changes show names instead of ids.


projects ​

list ​

bash
memrynote projects list

get ​

PositionalDescription
<id>Project id.

create ​

PositionalDescription
<name>Project name.
FlagTypeDescription
--description <text>string
--color <name>string
--icon <name>string

update ​

Positional <id>. Flags --name, --description, --color, --icon.

archive / unarchive ​

PositionalDescription
<id>Project.

delete (destructive) ​

Requires --yes.

reorder ​

PositionalDescription
<id...>Project ids in desired order.
FlagTypeDescription
--position <n>repeatableOne per id.

statuses ​

Lists statuses for a project.

PositionalDescription
<project-id>Project.

status-create ​

PositionalDescription
<project-id>Project.
<name>Status name.
FlagTypeDescription
--color <name>stringUI color.
--done <true/false>booleanTreats tasks in this status as completed.

status-update ​

PositionalDescription
<status-id>Status.
FlagTypeDescription
--name <text>string
--color <name>string
--position <n>numberColumn position.
--default <true/false>booleanMake default status for new tasks.
--done <true/false>boolean"Done" semantics.

status-delete (destructive) ​

Requires --yes.

status-reorder ​

PositionalDescription
<id...>Status ids.
FlagTypeDescription
--position <n>repeatableOne per id.

Links a note, file or calendar event to a project, or removes the link. A markdown note's membership is stored in its project frontmatter property, so link and unlink rewrite that property (other properties stay as they are). Files and calendar events use the project's link table and queue a project sync update.

Give exactly one of --note, --file or --event. Linking twice is a no-op.

PositionalDescription
<project>Project id.
FlagTypeDescription
--note <id>stringNote id.
--file <id>stringNon-markdown file id.
--event <id>stringCalendar event id.
--pinbooleanlink only: pin the item to the project overview.
bash
memrynote projects link proj_1 --note note_9 --pin

Lists a project's link rows (id, itemType, itemId, position, pinned, createdAt).

PositionalDescription
<project>Project id.

for-item ​

Lists the projects an item belongs to, oldest link first. Takes one of --note, --file or --event. Output: [{ id, name, color, icon }].

pin / unpin ​

Pins a linked item to the project overview, or unpins it. The link stays.

PositionalDescription
<project>Project id.
<item>Linked item id.

contents ​

What the project hub shows: linked notes, files and events, with links to missing items left out.

PositionalDescription
<project>Project id.
FlagTypeDescription
--type <list>repeatableOnly note, file, event; comma-separated allowed.

Output: { "notes": [], "files": [], "events": [], "counts": { "notes": 0, "files": 0, "events": 0 } }. Tasks are not part of it; use tasks list --project <id>. Unlike the desktop hub, items the desktop has not indexed yet still appear.

set-home-note ​

PositionalDescription
<project>Project id.
<note>Note id, or null to clear the home note.

Output: the updated project.

capture-url ​

Creates a note for a URL and links it to the project. The note title is the page's <title> when the page answers within 5 seconds, and the host plus path otherwise.

PositionalDescription
<project>Project id.
<url>Page URL.

Output: { "success": true, "noteId": "..." }.

import-files ​

Copies files into the vault and links them to the project. It needs the desktop app for any file that is not markdown: the CLI cannot give a new non-markdown file an id until the desktop app has indexed it. Those files are copied and reported under failed (exit code 1); link them later with projects link <project> --file <id>.

PositionalDescription
<project>Project id.
<path...>Files to import.
FlagTypeDescription
--folder <path>stringVault folder to import into.

Output: { "success": bool, "linked": ["<id>"], "failed": [{ "path": "", "error": "" }] }.


inbox ​

capture ​

PositionalDescription
<content>Text content.
FlagTypeDescription
--title <text>stringOptional title.
--tag <name>repeatableTag.
PositionalDescription
<url>Link.
FlagTypeDescription
--tag <name>repeatableTag.

capture-file ​

PositionalDescription
<file-path>File to import.
FlagTypeDescription
--mime <type>stringOverride detected MIME.
--title <text>string
--tag <name>repeatable

get ​

PositionalDescription
<id>Inbox item.

list ​

FlagTypeDescription
--archivedbooleanInclude archived.
--include-snoozedbooleanInclude snoozed.

tags ​

Returns tags used on inbox items.

stats ​

Returns counts (new, snoozed, archived, etc.).

patterns ​

Returns detected filing patterns.

archived ​

FlagTypeDescription
--search <text>string
--limit <n>numberDefault 50.
--offset <n>numberDefault 0.

filing-history ​

FlagTypeDescription
--limit <n>numberDefault 20.

stale-threshold ​

Returns the staleness cutoff in days.

set-stale-threshold ​

PositionalDescription
<days>Threshold in days.

update ​

PositionalDescription
<id>Inbox item.
FlagTypeDescription
--title <text>string
--content <text>string

add-tag / remove-tag ​

PositionalDescription
<id>Inbox item.
<tag>Tag name.

mark-viewed ​

PositionalDescription
<id>Inbox item.

convert-note / convert-task ​

Promotes an inbox item to a note or task.

PositionalDescription
<id>Inbox item.
<note-id>Target note.
FlagTypeDescription
--tag <name>repeatableTag.

snooze ​

PositionalDescription
<id>Inbox item.
FlagTypeRequiredDescription
--until <ISO>stringyesWake-up timestamp.
--reason <text>stringOptional reason.

unsnooze ​

PositionalDescription
<id>Inbox item.

snoozed ​

Lists currently snoozed items.

bulk-tag ​

PositionalDescription
<id...>Inbox item ids.
FlagTypeDescription
--tag <name>repeatableTags to apply.

bulk-snooze ​

PositionalDescription
<id...>Inbox item ids.
FlagTypeRequiredDescription
--until <ISO>stringyes
--reason <text>string

bulk-archive ​

PositionalDescription
<id...>Inbox item ids.

archive / unarchive ​

PositionalDescription
<id>Inbox item.

delete (destructive) ​

Requires --yes. Removes the inbox item permanently.

file ​

Files an item into a vault folder, as Filing does in the desktop Inbox. Text, link and clip items become a note in the folder (tagged inbox); image, voice, PDF and video items are moved out of the inbox into the folder under a name taken from the item's title. The item is marked filed and recorded in filing-history. The folder is created if missing and must stay inside the vault. Exits non-zero for an unknown item or one that is already filed.

PositionalDescription
<id>Inbox item.
FlagTypeRequiredDescription
--folder <path>stringyesVault-relative folder.
--tag <name>repeatableExtra tag on the note.

Returns { success, filedTo, noteId? }.

bulk-file ​

Files several items into one folder. Prints { success, processedCount, errors }; exits non-zero when any item failed.

PositionalDescription
<id...>Inbox item ids.

Flags as in file.

file-all-stale ​

Requires --yes. Files every active item older than the stale threshold (stale-threshold, default 7 days) into the Unsorted folder, as the desktop "file all stale" action does. Skips snoozed, archived and filed items.

convert-event ​

Turns a text or voice item into a calendar event and marks the item filed. Image, PDF, video and clip items cannot become events.

PositionalDescription
<id>Inbox item.
FlagTypeRequiredDescription
--start <ISO>stringyesStart time.
--end <ISO>stringEnd time.
--all-day <true/false>booleanDefault false.
--location <text>string

Returns { success, eventId }.

convert-reminder ​

Creates a note from a text or voice item, schedules a reminder on it, and marks the item filed. The time must be in the future.

PositionalDescription
<id>Inbox item.
FlagTypeRequiredDescription
--at <ISO>stringyesReminder time.

Returns { success, noteId }.

suggestions ​

Suggests folders for an item from the filing history: where earlier items of the same type were filed, with a confidence of count / total. Desktop also ranks with its local embedding model; the CLI does not.

PositionalDescription
<id>Inbox item.

Returns { suggestions: [{ destination: { type: "folder", path }, confidence, reason, suggestedTags }] }.

undo ​

undo archive <id> restores an archived item. undo file <id> reopens a filed item (it clears the filed state; it does not delete the note or move a filed file back).

capture-image / capture-pdf / capture-voice ​

Capture a file with the type checked: images (.png .jpg .jpeg .gif .webp .svg), PDFs (.pdf) or audio (.mp3 .wav .webm .m4a .ogg .flac .aac). Other extensions fail. Same flags as capture-file without --mime. capture-voice also queues a transcription job; the desktop app runs it the next time it opens the vault. Pass --transcribe false to skip it.

PositionalDescription
<file-path>File.
FlagTypeDescription
--title <text>string
--tag <name>repeatable
--transcribe <bool>booleancapture-voice only. Default true.

jobs ​

Lists the durable background jobs (link metadata, transcription, article extraction).

FlagTypeDescription
--item <id>repeatableOnly jobs for these items.
--status <name>repeatablepending, running, failed or complete.

Returns { jobs: [...] }.

retry ​

Re-queues the failed metadata scrape of a link item or the transcription of a voice item and sets it back to pending. The desktop app runs the job when it opens the vault. Other item types fail.

PositionalDescription
<id>Inbox item.

journal ​

get ​

PositionalDescription
<date>YYYY-MM-DD.

write ​

PositionalDescription
<date>YYYY-MM-DD.
<content>Replaces the entry body.

append ​

PositionalDescription
<date>YYYY-MM-DD.
<content>Appended to existing body.

delete (destructive) ​

Requires --yes.

PositionalDescription
<date>YYYY-MM-DD.

month ​

PositionalDescription
<year>Four-digit year.
<month>1–12.

heatmap ​

PositionalDescription
<year>Four-digit year.

stats ​

PositionalDescription
<year>Four-digit year.

context ​

Returns same-day notes, tasks, and reminders.

PositionalDescription
<date>YYYY-MM-DD.

tags ​

Returns tags used in journal entries.

streak ​

Returns the current writing streak.

properties ​

Returns the journal entries in a date range with their property values, as the desktop's journal property charts read them. rows holds { id, date, path, title, properties }, oldest first. properties lists every property any journal entry uses, with its type (the vault definition's, else the most common inferred type) and how many entries use it.

PositionalDescription
<from>First day, YYYY-MM-DD.
[<to>]Last day, YYYY-MM-DD. Defaults to <from>.
bash
memrynote --json journal properties 2026-03-01 2026-03-31

tags ​

list ​

bash
memrynote tags list

notes ​

PositionalDescription
<tag>Tag name.

color / set-color ​

PositionalDescription
<tag>Tag name.
[color]New color (or use --color).
FlagTypeDescription
--color <name>stringNew color.

rename ​

PositionalDescription
<old>Existing tag.
<new>New name.

remove-from-note ​

PositionalDescription
<note-id>Note.
<tag>Tag to remove from this note only.

merge ​

PositionalDescription
<source>Tag to merge from.
<target>Tag to merge into (kept).

delete (destructive) ​

Requires --yes. Removes the tag from every entity.

Tags with fields ​

A tag can carry a schema of fields (see Tags with fields in the app). A note whose header (frontmatter) tags include the tag is an object of it. Put flags after the positionals: a flag followed by a bare word takes the word as its value.

Every write here also queues a sync intent, so a running or later-started desktop app sends the change to your other devices. Pinning is the exception (see pin).

schema ​

bash
memrynote tags schema                       # every tag with fields, plus note id -> primary object tag
memrynote tags schema <tag>                 # one tag's resolved schema (also: schema show <tag>)

Returns resolved tags: own, inherited and effective fields, extends, ancestors, template and preset. Exits non-zero for a tag with no fields. A tag named like one of the verbs below is read with schema show <tag>.

VerbDescription
schema add-field <tag> <field> --type <t>Add a field. Types: text, number, checkbox, date, url, status, select, multiselect, relation.
schema remove-field <tag> <field> (destructive)Remove a field from the schema. Values stay in notes and tasks. Without --yes, it reports how many are filled.
schema move-field <tag> <field> <index>Move a field to a zero-based position.
schema set-relation <tag> <field> --target <t>Point a field at a tag (makes it a relation).
schema set-template <tag> <template-id|none>Set or clear the template for new objects.
schema set-extends <tag> <parent|none>Inherit fields from a parent tag. Needs --yes when the tag would lose inherited fields.
FlagUsed byDescription
--type <t>add-fieldField type. The vault-wide property definition wins when one already exists.
--options a,b,cadd-fieldOptions for select and multiselect when the property is new.
--index <n>add-fieldInsert at this position instead of the end.
--target <tag>relation fieldsRequired for a relation.
--manyrelation fieldsThe relation holds several notes.
--inverse <label>relation fieldsLabel of the inverse list on the target.
--autofillset-templateFill the template into new objects automatically.
--yesremove-field, set-extendsConfirm.

add-field creates the property definition (and .memry/properties.md entry) when none of that name exists. These need the desktop app and fail with a clear error here: schema rename-field (rewrites the property in every note and task, with progress and resume) and schema add-preset (localized preset catalog).

impact ​

Counts what a change would affect, before you run it.

bash
memrynote tags impact remove-field <tag> <field>      # { filled, empty }
memrynote tags impact rename-field <field>            # { notes, tasks, tags }
memrynote tags impact delete-tag <tag>                # { notes, tasks, values, fields, templateName }
memrynote tags impact set-extends <tag> <parent|none> # { notes, gained, lost }
memrynote tags impact become-objects <tag>            # { notes }

objects ​

bash
memrynote tags objects [<tag>] [--query <text>] [--limit <n>]

Searches objects (notes with the tag in their header). <tag> limits it to that tag and the tags that extend it. --query matches titles, ignoring case and diacritics. --limit is 1 to 50 (default 12). Returns { matches: [{ noteId, title, tag, groupTag, viaTag, subtitle, modified }], complete }.

linked-here ​

bash
memrynote tags linked-here <note-id> [--limit <n>]

Groups what points at the note: notes through a relation field, tasks through a task field, and notes that link it in their body. --limit is items per group, 1 to 500 (default 2).

categories ​

CommandDescription
tags categories or tags categories listCategories with their tag counts.
tags categories create <name>Create a category.
tags categories rename <id> <name>Rename.
tags categories reorder <id>...Set the category order to the order given.
tags categories delete <id> (destructive)Requires --yes. Its tags become uncategorized.

set-icon ​

bash
memrynote tags set-icon <tag> <icon>    # an emoji or "icon:Name"
memrynote tags set-icon <tag> --clear

pin / unpin ​

bash
memrynote tags pin <tag> <note-id>
memrynote tags unpin <tag> <note-id>

Pins a note at the top of the tag page. Pins live in the search index that the desktop app maintains, so a note the desktop app has not indexed yet fails with a message to open it there first. Pins are local to this device.

reorder ​

bash
memrynote tags reorder <tag>... [--category <id|none>]

Sets the sort order of the listed tags to the order given. --category moves them all into a category (or none); without it each tag keeps its category.

fill-status / fill-fields ​

Filling a tag's fields asks an AI model and uses the desktop app's AI settings and disclosure, so both commands exit non-zero and name the desktop app.


settings ​

list ​

Returns all key/value settings.

groups ​

Lists logical groups (UI sections): general, editor, tasks, keyboard, sync, backup, graph, calendar (and calendar.google, calendar.ics, calendar.caldav), voiceTranscription, journal, tabs, noteEditor, features, inbox, sticky, graphViews, tagSearches and sidebar.

sidebar is a view over the desktop's sidebar.* settings with the fields navCollapsed, notesFirst and showFiles (booleans), sectionOrder and railOrder (arrays of ids) and sortModes (an object). set-group sidebar rejects unknown fields and values of the wrong type. The CLI does not queue these changes for sync, like the other groups.

group ​

PositionalDescription
<name>Group name.

set-group ​

PositionalDescription
<name>Group name.
<json>Partial settings object for the group.

ai ​

Returns AI settings.

set-ai ​

PositionalDescription
<true/false>Enable or disable AI features.

get ​

PositionalDescription
<key>Setting key.

set ​

PositionalDescription
<key>Setting key.
<value>Value (parsed as JSON if possible).

delete (destructive) ​

Requires --yes.


locale ​

get ​

Returns the active locale code.

set ​

PositionalDescription
<code>Locale code (e.g. en-US, tr-TR).

list ​

Lists supported locales.


reminders ​

create ​

PositionalDescription
<target-type>note, journal, or highlight.
<target-id>Id of the targeted entity.
FlagTypeRequiredDescription
--at <ISO>stringyesFire time.
--title <text>string
--note <text>string
--highlight-text <text>stringFor highlight target.
--highlight-start <n>numberCharacter offset.
--highlight-end <n>numberCharacter offset.

get ​

PositionalDescription
<id>Reminder id.

update ​

PositionalDescription
<id>Reminder id.
FlagTypeDescription
--at <ISO>stringNew fire time.
--title <text/null>string
--note <text/null>string

list ​

FlagTypeDescription
--target-type <name>stringnote, journal, or highlight.
--target-id <id>string
--status <name>stringpending, triggered, dismissed, or snoozed.
--from <ISO>stringWindow start.
--to <ISO>stringWindow end.
--limit <n>numberDefault 50.
--offset <n>numberDefault 0.

for-target ​

PositionalDescription
<target-type>note, journal, or highlight.
<target-id>Entity id.

due ​

Returns reminders past their fire time.

upcoming ​

FlagTypeDescription
--days <n>numberWindow. Default 7.

dismiss ​

PositionalDescription
<id>Reminder.

snooze ​

PositionalDescription
<id>Reminder.
[until]New ISO time, or use --until.
FlagTypeDescription
--until <ISO>stringNew fire time.

count-pending ​

Returns the count of pending reminders.

bulk-dismiss ​

PositionalDescription
<id...>Reminder ids.

delete (destructive) ​

Requires --yes.


templates ​

Custom templates live in the vault database (data.db) and sync across devices, the same store the desktop app uses. Legacy .memry/templates/*.md files are imported once on first run and then left on disk as a downgrade path. Desktop's built-in templates are not listed here.

list ​

bash
memrynote templates list

get ​

PositionalDescription
<id>Template id.

create ​

PositionalDescription
<name>Template name.
FlagTypeDescription
--description <text>string
--icon <name>string
--content <text>stringTemplate body.
--tag <name>repeatableTag.

update ​

Positional <id>. Flags --name, --description, --icon, --content, --tag.

duplicate ​

PositionalDescription
<id>Source template.
<new-name>Name for the duplicate.

delete (destructive) ​

Requires --yes.


bookmarks ​

list ​

FlagTypeDescription
--type <name>stringFilter by item type.

get ​

PositionalDescription
<id>Bookmark id.

get-by-item ​

PositionalDescription
<item-type>e.g. note, task.
<item-id>Item id.

list-by-type ​

PositionalDescription
<item-type>Item type filter.

add ​

PositionalDescription
<item-type>Item type.
<item-id>Item id.

toggle ​

Same positionals as add. Adds if missing, removes if present.

remove ​

PositionalDescription
<item-type>Item type.
<item-id>Item id.

delete (destructive) ​

Requires --yes. Removes by bookmark id.

PositionalDescription
<id>Bookmark id.

has ​

PositionalDescription
<item-type>Item type.
<item-id>Item id.

Returns { bookmarked: boolean }.

reorder ​

PositionalDescription
<id...>Bookmark ids in desired order.

bulk-create ​

PositionalDescription
<json-array>JSON array of { "itemType", "itemId" }.
bash
memrynote bookmarks bulk-create '[{"itemType":"note","itemId":"note_1"}]'

bulk-delete ​

PositionalDescription
<id...>Bookmark ids.

saved-filters ​

list ​

bash
memrynote saved-filters list

get ​

PositionalDescription
<id>Saved filter id.

create ​

PositionalDescription
<name>Filter name.
FlagTypeDescription
--config <json>JSONFilter config. Defaults to {}.

update ​

PositionalDescription
<id>Saved filter id.
FlagTypeDescription
--name <text>stringNew name.
--config <json>JSONNew config.

reorder ​

PositionalDescription
<id...>Filter ids in desired order.
FlagTypeDescription
--position <n>repeatableOne per id.

delete (destructive) ​

Requires --yes.


calendar ​

Calendar groups several sub-namespaces. The top-level subcommands are:

sources | select-source | provider-status | google-settings |
set-default-google-calendar | range | external <action> |
bindings <action> | events <action>

sources ​

FlagTypeDescription
--provider <name>stringFilter by provider.
--kind <name>stringFilter by kind.
--selectedbooleanOnly return selected sources.

select-source ​

PositionalDescription
<source-id>Source id.
FlagTypeDescription
--selected <true/false>booleanSelection state. Default true.

provider-status ​

PositionalDescription
[provider]Provider name (or use --provider).
FlagTypeRequiredDescription
--provider <name>stringyes (or positional)Provider name.
--account <id>stringAccount scope.

google-settings ​

Returns the active Google calendar configuration.

set-default-google-calendar ​

PositionalDescription
<calendar-id/null>Google calendar id, or null to clear.
FlagTypeDescription
--calendar <id/null>stringAlternative to positional.
--mark-onboarding <true/false>booleanDefault true.

range ​

Returns events from all selected sources in a window.

FlagTypeRequiredDescription
--start <ISO>stringyesWindow start.
--end <ISO>stringyesWindow end.
--include-unselectedbooleanInclude unselected sources.

external list ​

FlagTypeDescription
--source <id>stringSource filter.
--archivedbooleanInclude archived.
--start <ISO>stringWindow start.
--end <ISO>stringWindow end.

external get ​

PositionalDescription
<event-id>External event id.

external promote ​

Promotes an external event to a managed memrynote event.

PositionalDescription
<event-id>External event id.

bindings list ​

FlagTypeDescription
--source-type <name>string
--source <id>string
--provider <name>string
--archivedboolean

bindings get ​

PositionalDescription
<binding-id>Binding id.

events create ​

PositionalDescription
<title>Event title.
FlagTypeRequiredDescription
--start <ISO>stringyesStart time.
--end <ISO>stringEnd time.
--timezone <tz>stringDefault UTC.
--description <text>string
--location <text>string
--all-day <true/false>booleanDefault false.

events get ​

PositionalDescription
<event-id>Event id.

events list ​

FlagTypeDescription
--start <ISO>stringWindow start.
--end <ISO>stringWindow end.
--archivedbooleanInclude archived.

events update ​

PositionalDescription
<event-id>Event id.
FlagTypeDescription
--title <text>string
--start <ISO>string
--end <ISO/null>string
--timezone <tz>string
--description <text/null>string
--location <text/null>string
--all-day <true/false>boolean

events delete (destructive) ​

Requires --yes.

Title search over events, upcoming and past, nearest to now first (the desktop picker's ranking).

PositionalDescription
<text>Case-insensitive title text.
FlagTypeDescription
--limit <n>numberDefault 20, at most 100.
--include-externalbooleanAlso search mirrored provider events (kind: "external_event").

Returns { events: [{ id, title, startAt, endAt, isAllDay, kind? }] }.

linked-notes ​

Notes whose relation properties link to an event.

PositionalDescription
<event-id>Event id.
FlagTypeDescription
--externalbooleanThe id is a mirrored provider event id.

Returns { notes: [{ id, title, emoji }] }.

providers ​

Lists the providers the desktop app knows (google, caldav, apple-eventkit, ics) with whether an account is connected and how many calendars this vault mirrored. Connecting or disconnecting a provider needs the desktop app's sign-in and is not available here.

provider-calendars ​

The calendars this vault mirrored for a provider, plus the current default (Google only). Desktop asks the provider live; the CLI reads what was last synced.

FlagTypeRequiredDescription
--provider <name>stringyesProvider id.

set-default-calendar ​

Sets the calendar new events are written to. Only --provider google (the default) works from the CLI; other providers exit non-zero and point at the desktop app.

FlagTypeDescription
--provider <name>stringDefault google.
--calendar <id/null>stringCalendar id, or null to clear (or pass it as the positional).
--mark-onboarding <true/false>booleanDefault true.

refresh / retry-sync / writer-compat ​

refresh --provider <name>, retry-sync <source-id> and writer-compat --provider <name> need the desktop app's provider sign-in and network sync. They check their arguments, then exit non-zero with a message that says so.

ics subscribe ​

Subscribes to a calendar feed by URL (http, https, webcal). The feed is fetched first, so a wrong link fails with a reason (invalid_url, unreachable, timeout, not_found, unauthorized, http_error, too_large, not_a_calendar) instead of leaving an empty calendar. Subscribing to an already-subscribed URL returns that source; a removed one is restored. The CLI writes the source row; the desktop app's feed runner reads the events on its next pass.

PositionalDescription
<url>Feed URL.
FlagTypeDescription
--name <text>stringTitle. Default: the feed's own name, then its host.

ics unsubscribe (destructive) ​

Requires --yes. Archives the subscription and drops this vault's mirrored events for it.

PositionalDescription
<source-id>ICS source.

ics update ​

PositionalDescription
<source-id>ICS source.
FlagTypeDescription
--name <text>stringNew title.
--color <name>stringOne of the event colours: tomato, flamingo, tangerine, banana, sage, basil, peacock, blueberry, lavender, grape, graphite.

ics refresh ​

Needs the desktop app (it parses the feed); exits non-zero with a message that says so.


sync ​

status ​

Returns the live sync state (linked? paused? last cursor? errors?).

queue-size ​

Returns the pending outbound queue size.

history ​

FlagTypeDescription
--limit <n>numberDefault 50.
--offset <n>numberDefault 0.

devices ​

Lists known devices for this account.

storage ​

Returns the encrypted-blob storage breakdown by type.

quarantine ​

Lists items the engine quarantined (typically schema mismatches).

check-device ​

Verifies this device is still authorized.

pause / resume ​

Toggles the sync engine.

settings ​

Returns the synced-settings snapshot.

update-setting ​

PositionalDescription
<path>Dot-separated path within synced settings.
<value>New value (parsed as JSON if possible).

trigger / progress / rename-device / remove-device ​

trigger (Sync now), progress (live attachment transfer progress), rename-device <id> <name> and remove-device <id> --yes need the desktop app's signed-in session or its in-memory state. They exit non-zero with a message that says so. Use status, queue-size and devices to read state.

note-state ​

How far a note's body got toward the server, from local facts: not_syncing, local_only, pending, sent, rejected, confirmed or not_recorded. The CLI treats the vault as syncing when it has a linked current device.

PositionalDescription
<note>Note id or path.

Returns { state, waitingSince, lastSentAt, bodyConfirmedAt, lastFailedAt, lastRejectedAt }.

unsent-notes ​

Notes with changes the server has not stored (queued body or record changes, a file the note's document has not taken, or a refused push). Rejected notes first, then oldest. Returns { total, notes: [{ id, title, path, state, waitingSince, reasons }] }, at most 200 notes.

large-notes ​

Notes at or over the per-note sync size ceiling. Returns { maxBytes, notes: [{ id, title, path, sizeBytes, status }] } with status approaching or over, largest first, at most 50.

binding ​

The account choice stored in this vault: { status: "unbound" | "sync" | "local-only", mode }. Desktop's needs-decision and foreign states depend on a server check and are not computed here.


agent ​

backends ​

Returns availability + version info for each agent backend.

models ​

PositionalDescription
[backend]claude_cli, codex_cli or antigravity_cli (or use --backend).
FlagTypeDescription
--backend <name>stringclaude_cli, codex_cli or antigravity_cli.

local-settings ​

Returns the local-provider settings used by Agent Chat.

set-local-settings ​

FlagTypeDescription
--preset <name>stringollama, lm_studio, llama_cpp, or custom.
--base-url <url>stringBase URL.
--model <name>stringDefault model.
--allow-non-loopback <true/false>booleanAllow non-localhost URLs.

conversations / conversation ​

conversations lists Agent Chat conversations, newest first. conversation <id> shows one. Each record is { id, backend, backendModel, pinned, messageCount, createdAt, updatedAt }. Titles and messages are encrypted with the vault key held in the OS keychain, so the CLI cannot read them and never prints them.

local-models ​

Lists the models the configured local provider serves (GET <base-url>/models). An unreachable provider returns { "models": [] }. A non-loopback URL needs --allow-non-loopback true in set-local-settings. The provider's API key lives in the keychain and is not sent.

test-local ​

Checks the local provider is reachable and serves the chosen model. Returns { connected, modelAvailable, streamingSupported, toolCallingSupported, toolContinuationSupported, toolsEnabled, detail } (the CLI does not probe tool calling).

preferences / set-preferences / mcp-status / mcp ​

preferences, set-preferences, mcp-status, mcp status and mcp rotate-token --yes read state the desktop app keeps in its own config or in memory (chat access and approval mode, the MCP server URL and token). They exit non-zero with a message that says so; the token is never printed here.


graph ​

data ​

Returns the full link graph for visualization.

local ​

PositionalDescription
<note-id>Center note.
FlagTypeDescription
--depth <n>numberHops out. Default 2.

stats ​

Returns index size and last-build info.

reasons ​

Lists recent items the search engine highlighted.

add-reason ​

PositionalDescription
<item-id>Item id.
<item-type>note, journal, task, or inbox.
<item-title>Display title.
<search-query>Query that surfaced the item.

clear-reasons ​

Removes all stored search reasons.

tags ​

Returns tags discovered while indexing.

rebuild-index ​

Reports the index size. Returns { started: true, indexed: <n> } and does not rebuild anything. To rebuild the search index, run vault reindex.

(free text) ​

Any other subcommand or arguments are joined with spaces and treated as a search query. Results are an array of { kind, id, title, path?, snippet? }. Notes, journal entries, tasks and inbox items that the full-text index knows come first, ranked like the desktop search (matching alias, then words next to each other, then relevance), and a substring scan adds what the index has not caught up with. Text, quoted phrases and AND/OR/NOT work as in the desktop search.

FlagDescription
--type <kind>Only these kinds: note, journal, task, inbox, reminder, template, calendar. Repeat or comma-separate.
--tag <tag>Only items with any of these tags. Repeat or comma-separate. Leading # is ignored.
--from <date>Only items modified at or after this ISO date or time.
--to <date>Only items modified at or before this ISO time. A bare YYYY-MM-DD covers that whole day.
--project <id>Only tasks in this project.
--folder <prefix>Only notes and journal entries whose path starts with this prefix (for example Projects/).
--limit <n>Return at most n results (at least 1).
--offset <n>Skip the first n results.

--tag, --from, --to, --project and --folder apply to notes, journal entries, tasks and inbox items only. Setting any of them leaves out reminders, templates and calendar events. Semantic (embedding) search and the fuzzy title fallback need the desktop app and are not part of the CLI search.

bash
memrynote search project plan
memrynote --json search "encryption nonce"
memrynote search zebra --type note --tag animals --folder Zoo/ --limit 10
memrynote search "weekly review" --from 2026-01-01 --to 2026-01-31

canvas ​

Canvases are .excalidraw documents under <vault>/canvases/, indexed in the data database. The CLI lists, reads, creates, copies, deletes and exports them. Drawing is done in the desktop app.

list ​

FlagDescription
--folder <path>Only canvases in this folder (relative to canvases/).

Returns [{ id, title, folder, icon, ownerNoteId, createdAt, updatedAt, itemCount, unreadable }], newest first. itemCount is the number of note, task, event, project and file cards. unreadable is true when the document is missing from disk.

get ​

PositionalDescription
<id>Canvas id.
FlagDescription
--no-sceneLeave out the scene JSON.

Returns the summary plus scene, the Excalidraw scene as a JSON string. unreadable: true and an empty scene mean the document is missing.

create ​

FlagDescription
--title <text>Title. The file is named after it (Plan.excalidraw, Plan 2.excalidraw, ...).
--folder <path>Folder under canvases/, up to 8 levels deep.
--icon <icon>Icon name or emoji.
--scene-file <path>Start from this Excalidraw JSON file. It must parse as JSON.

Writes the document, indexes its entity cards and arrows, and returns the canvas. The row has no sync clock; the desktop app seeds it on its next start.

duplicate ​

memrynote canvas duplicate <id> copies the scene and its image asset rows next to the original (same folder and icon, title numbered). Fails when the original is missing or unreadable.

delete (destructive) ​

memrynote canvas delete <id> --yes removes the document file and returns { deleted, syncPending }. A canvas that never synced is also tombstoned in the database. One that has synced keeps its row (listed as unreadable) and syncPending is true: the desktop app turns the missing document into a synced delete the next time it runs.

export ​

memrynote canvas export <id> [--out <path>] writes the scene as a plain Excalidraw file (without Memry's sidecar) to --out, or prints it to stdout. It refuses to overwrite an existing file.


home-pages ​

Reads the home boards. Widgets and covers are edited in the desktop app.

list ​

Returns every board in position order: [{ id, name, icon?, position, widgets, cover? }]. Boards saved before the resizable grid get coordinates from their size letter, as in the desktop app.

get ​

memrynote home-pages get <id> returns one board. Fails when it does not exist.


icons ​

The vault's custom icon library (.memry/icons/).

list ​

Returns [{ id, name, ext, path, createdAt }]. A missing icon file is rebuilt from the database row.

add ​

PositionalDescription
<path>An .svg or .png file.
FlagDescription
--name <text>Label, up to 60 characters. Defaults to the file name.

SVG is sanitized like the desktop app does (scripts, event handlers, external references removed). The desktop app re-encodes raster images to PNG and downscales them; the CLI cannot, so it accepts only PNG files up to 128 px on the longest edge and up to 2 MB, and asks you to convert other formats first.

rename ​

memrynote icons rename <id> <new-name>.

delete (destructive) ​

memrynote icons delete <id> --yes removes the icon and its file. An icon that has synced also gets a pending-delete record so the desktop app can tell your other devices; the result's syncPending says so.


import ​

Brings files from other apps into the vault, using the parsers the desktop importers use.

sources ​

Lists every importer the desktop app has, as [{ id, name, extensions, directory, cli, reason? }]. cli: true sources run from the command line: markdown, csv, roam. For the others, reason says why they stay in the desktop app (attachments, tasks, account sign-in, or the macOS Notes container and its password prompt). import start on one of them exits non-zero with that reason.

preview ​

memrynote import preview <source> <path...> [--folder <vault-folder>] plans the import and prints { groups: [{ label, counts, sampleTitles, warnings?, error? }] } per source file. Nothing is written.

start ​

memrynote import start <source> <path...> [--folder <vault-folder>]

SourceReadsDefault folder
markdown.md / .markdown files or foldersMarkdown
csvCSV files, one note per rowCSV
roamRoam JSON exportsRoam

--folder replaces the importer's own root and keeps subfolders (Markdown/sub becomes <folder>/sub). Returns { importer, imported, attachments, skipped, failed, warnings, notes }.

Differences from the desktop import, listed in warnings: attachments are not copied (attachments is always 0), checklists stay plain markdown instead of becoming tasks, and Roam page dates are not carried over. Importing the same files twice creates the notes twice.


readwise ​

The part of the Readwise importer that needs only the vault's databases. The token lives in the OS keychain and pulls run in the desktop app's scheduler, so those stay in the desktop app.

status ​

Returns { connected, options, lastSyncAt, needsAttention, attention, hasImported, lastRun, pullingDevice }. connected is always null: the CLI never reads the keychain. hasImported and lastSyncAt show whether a run has completed. pullingDevice names the device that holds the pull claim.

list-deleted ​

Lists notes the user deleted that Readwise will not recreate: [{ readwiseBookId, noteId, deletedAt }], newest first. The desktop app also shows titles and highlight counts, which need the Readwise API.

set-options ​

FlagDescription
--root-folder <path>Vault folder for imported notes.
--folder-layout <by-category|flat>Folder layout.
--cadence <manual|hourly|daily>How often the desktop app pulls.
--category <name>=on|offRepeatable. books, articles, tweets, podcasts, supplementals.
--reader-documents on|offAlso import saved Reader documents.
--reader-full-text on|offImport their full text.
--journal on|offAdd new highlights to the journal.

Writes the same readwise settings group the desktop app uses, and flags a full re-read when a category or Reader documents switch on. Returns the new status.

sync-now / restore-book / reimport-book / refresh-book / take-over ​

Exit non-zero with a pointer to Settings → Import → Readwise. They need the stored token and the desktop app's sync scheduler, and a second runner from the CLI could race it.


Exit codes ​

CodeMeaning
0Success.
1Any thrown error. Message is written to stderr.

The most common error messages are:

  • Missing <label> — a required positional is missing.
  • Invalid number: <value> or Invalid boolean: --<flag> — a flag failed to parse.
  • Pass --yes to delete a <thing> — a destructive command needs the safety flag.
  • Multiple vaults found. Choose one with memrynote vault use ... or run with --vault <path>.
  • No default vault configured. Open memrynote and choose Settings > Command Line > Default vault, or run with --vault <path>.

Environment variables ​

VariableMeaning
MEMRY_MIGRATIONS_DIRDirectory holding drizzle-data/ and drizzle-index/. An escape hatch — the CLI finds them on its own, both from a packaged install and from a source checkout. Set it only if it ever reports that it could not.

If a command fails with Could not find the drizzle-data migrations folder, the error lists every path that was checked; point MEMRY_MIGRATIONS_DIR at the right one and please open an issue, since finding them should not need help.

Released under the GNU GPL v3.0.