Verde

Archive a document: it is retained for history but excluded from normal retrieval. Archiving a document that is published PUBLIC also removes it from the public knowledge base immediately, so it is no longer served on the open internet. Nothing is permanently deleted.

archive_memory

Leave a comment on a document, reply to a thread, or resolve one. A comment is discussion and never changes the document — use update_memory for that. Typical uses: after editing a document to address a thread, reply with `reply_to` set to the thread's id and `resolve: true`, stating what you changed; when the user asks you to review a document, or you find something you can't settle yourself (a likely-stale fact, a contradiction with another document, a question for its author), start a thread about it. Don't comment unprompted on every document you read. To anchor a new thread to a passage, pass `quote`: a short span copied from the document's current text that appears only once (formatting and punctuation are ignored). To comment on a whole section, pass `section` with its heading text instead. Omit both to comment on the whole document. `resolve: false` on a reply reopens a resolved thread. You can resolve a thread only if the user opened it or can edit the document. Comments are visible to everyone who can see the document (a private document's only to its owner), are attributed to the user via this client, and never appear on public pages or share links. The response carries a `url` to the thread.

add_comment

Create a bucket (folder) with a default visibility of public, company, or private. Prefer reusing an existing bucket (see list_buckets) — if a bucket with a highly similar name exists, it is returned instead of creating a duplicate.

create_bucket

Create a new document in a bucket. Use proactively: when the user states a durable decision, preference, project fact, or correction, offer to save it — don't wait to be asked. One document = one fact, with a declarative title that states it; search_memories first so you update or supersede an existing document instead of duplicating. Never save secrets or credentials. Documents start as drafts unless publish=true. Company and Private documents publish directly (write permission). PUBLIC documents are NEVER published by this tool: publish=true on a public document saves a draft and returns its id, and taking it live is a deliberate second step — show the user the exact content, get their explicit approval, then call publish_memory with confirm_public: true. Visibility defaults to the bucket's baseline and may be narrower (e.g. a private note in a company bucket) but never wider. Never put personal or private information in company or public documents. The response includes a `url` to the document's page — offer it when the user would want to open the document itself (a design doc, plan, or decision), not on every routine save.

propose_memory

Retrieve one complete document — or several at once — with metadata, source, status, supersession history, and cross-references. `references` lists the documents this one links to (via [[Title]]) and `referenced_by` lists documents that link to it, each as { id, title }: to follow a reference, pass those ids straight to this tool (use `ids` to fetch a batch in a single call) rather than searching. Each document carries a `url` to its page — share it when the user would want to open the document itself (a design doc, decision, or plan), not on routine reads. A document that already has an unlisted share link also carries `shared.url`: hand that one over when the user wants a link to send OUTSIDE the team, since it opens with no sign-in. You cannot create or revoke a share link yourself — that stays a person's decision, made in Verde. When a document has no link yet but could have one, it carries `share_setup_url` instead: give the user that URL and it opens Verde's Share dialog for this exact document, one click from a link they can send. Offer `share_setup_url` ONLY when the user has raised sharing or asked for a link to send someone — never volunteer it on an ordinary read, and never present it as a link to the document itself (that is `url`). It also carries a `version`: keep it and pass it as `expected_version` if you later call update_memory, so your edit is refused rather than overwriting a change someone made in between. A document people have left unresolved comments on carries `open_comments` (how many threads): before editing it, read them with list_comments — they are usually requests for exactly the kind of change you are about to make. Each retrieval is recorded in the vault's activity log (the document, and for non-private documents its title) for the team's usage analytics; recalls of your private documents are recorded privately and visible to you alone.

get_memory

List a vault's buckets (folders). Each bucket has a default visibility — public, company, or private — which its documents inherit; an individual document may be MORE restricted than its bucket (e.g. a private draft inside a company bucket) but never more visible. Private buckets belong to the authenticated user only.

list_buckets

Recently created or updated documents you can access — a quick way to catch up on what the company (and you) recently learned. Each result carries a short excerpt, not the full document — fetch full content for the relevant ones with get_memory (batch `ids` supported). Each result also carries a `url` to its page you can share with the user.

list_recent_memories

Discover every team and vault this connection can reach, with your role and permission level. By default that is every team the user belongs to (including teams joined after connecting); a connection can also be limited to selected teams or one vault, and anything outside that is never listed or reachable here. Pass a vault's 'team/vault' slug as the `vault` argument on any other tool to choose where to read or write. Start here when you're unsure where knowledge belongs.

list_vaults

Take a draft document live. Company and Private drafts publish with write permission. PUBLIC drafts require BOTH that the user behind this token holds publish permission AND confirm_public: true — publishing a public document puts it on the open internet immediately and is not something to do on your own initiative. Before setting confirm_public, show the user the document's exact title and full body, tell them it will be publicly visible, and get an explicit yes. Without publish permission the draft stays put for a publish-level member to take live. The response includes the document's `url`; a published public document's link opens for anyone with no sign-in, so it's the one to hand the user when they want to read it on the web.

publish_memory

Read the comment threads on a document — notes people (and AI clients) left about what should change and why. get_memory reports `open_comments` when a document has unresolved threads; read them before you edit it. Each thread has the comment, who left it (`via` names the AI client when it came through one), any replies, and what it's about: a `quote` (a passage), a `section` (the whole section under that heading), `area: 'block'` (the whole paragraph or block beginning with `quote`), or `area: 'range'` (everything from `quote` through `quote_end`); none of these means the whole document. `outdated: true` means that text is no longer in the document. `on_version` is the document version the comment was written against. To act on a thread: make the change with update_memory (or supersede_memory), then reply with add_comment, `reply_to` the thread's id and `resolve: true`, saying briefly what you changed. Leave a thread open if you did not fully address it or it needs the user's decision, and tell the user. Returns open threads only unless include_resolved is true. Reading comments records nothing in the activity log.

list_comments