Lekh

Find Lekh boards and folders: by folder, recent, starred, shared, or search. Use this first when the person names a board rather than giving you its id, or asks what they have. `view` picks what to list: `folder` for one folder's contents, `recent`, `starred`, `shared`, or `search` to match a query across their own boards. Note two limits: `recent` and `starred` return a single page and have no more to fetch, and `search` covers only the user's personal documents — a board inside a workspace will not appear, so an empty result does not prove it does not exist. To page, pass the returned `next_token` back with the identical query; changing anything means starting over. Paging, sharing and workspaces are in the `dashboard` guide (tool `guide_read`).

docs_list_items

List saved Lekh shapes and templates: the person's own, system or public. Use it when they refer to something of theirs — "my org chart template". For the built-in catalogue use `stencil_search`. A shape saved moments ago may not appear here yet. Give `kind` to page: with it omitted, shapes and templates are listed together and there is no continuation to follow.

library_list_items

List the Lekh shape catalogue's categories and the groups they sit in. They are Flowchart, UML, UI Wireframe, BPMN, the cloud-vendor sets and the rest. Use it to narrow a search that found nothing, or to tell the person what kinds of diagram Lekh can draw.

stencil_list_categories

List who has access to a Lekh board, and at what level. Check this before sharing, so you can tell the person what would change.

docs_list_shares

Move a Lekh board into a folder, or to the root by omitting `parent`. Folders cannot be moved — that is a product limitation, not an argument you can work around, and attempting it returns `cannot_move_folder`. To reorganise folders, tell the person what is not possible.

docs_move_item

Outline a Lekh board: its pages, their bounds, counts and size, not its objects. Per page: id, name, order, canvas_type, bounds, how many nodes, edges and free-hand strokes it has, and `projected_bytes`, what reading it with `board_read` carries — divide by 150,000 (or your `max_bytes`) for the number of responses. Use it to choose a `page` or `region` before reading a large board. `board_read` embeds the same outline in every response.

board_outline

Preview what an edit would do to a Lekh board, without changing it. Takes exactly what `board_edit` takes and returns the rendered result; nothing is written and nobody sees anything. Use it between building a batch and sending it, especially on a board someone else may have open. It takes `board_edit`'s arguments, `conflict_policy` included: by default a stale `version` is previewed against the current board with a note, exactly as the edit would apply; `strict` refuses it with `board_version_conflict`. Pass `region` or `node` (with `padding`) to see part of the page, as `board_render` does. Look at the image: check that anything you added matches its neighbours, overlaps nothing, and neither hides nor is hidden behind another shape. The picture uses this server's font family; size, colour and positions are the board's. Fix text that clearly spills out of its shape; ignore a line that is only slightly tight.

board_preview_edit

How to draw in Lekh: guides per diagram type, layout, format and errors. `getting-started` is the map — the five tool families, the rules that hold everywhere, and which guide to read when; start there. `semantic-board-format` is what `board_read` returns and the coordinate conventions, with `semantic-board-fields` for every field and `semantic-board-schema` for the JSON Schema; `editing-boards` is the operation set and the version rule; `visual-design` is how to lay out and style a diagram; `stencils` is how the catalogue works; `dashboard` covers files, folders and sharing; `limits-and-errors` says what fits in one read and what each error means. `diagram-types` routes each kind of diagram — flowchart, UML, ER, BPMN, cloud, … — to its own guide; read it before drawing. Each guide is also an MCP resource, `lekh://guide/<name>`.

guide_read

Read a Lekh board as pages of nodes and edges, with text, styles and shape ids. Positions are in points. Call this before any edit — the `version` it returns is required by `board_edit`, and the object ids are how you address anything. Every page comes back by default, in parts: each response carries at most 150,000 bytes of JSON (or your `max_bytes`) and an `outline` of the whole board. If `next_token` is not null, objects are still to come: call again with it, and follow it until it is null before you summarise the board as if it were whole. If the board changes mid-read, the next part is refused with `board_version_conflict` unless you pass `if_changed: "continue"`. Narrow a large board with `page`, `region` or `include_style: false`; `board_outline` gives the outline alone. This is a projection of the board's content — its nodes, edges and text as data — not a picture of it. Free-hand drawings are not in it: they are left out of `nodes` (each page's `freehand` counts them and `notes` says so), and a shape with its own drawing reads as `lekh.semantic.path` with a `draw`. To see how the board actually looks — free-hand drawings included, with generated shapes, colours and layout — call `board_render`. It is the only representation of board content this server offers; there is no raw file format. How to read it — coordinates above all — is the `semantic-board-format` guide (tool `guide_read`), which leads to every field's meaning; for what drives a shape marked `generated`, call `stencil_get`.

board_read

Rename a Lekh board or folder. This is the item's name in the dashboard, not any title drawn on the board itself — to change text on the canvas, use `board_edit`.

docs_rename_item

Render a Lekh board, one shape on it, or content not yet saved, as a PNG. Three ways to use it, and the third is the one worth remembering: pass `docid` to see a stored board; add `node` to see one shape from it, which is the only way to see a shape marked `generated`; or pass `content` — a board in the same schema `board_create_content` takes — to render something that does not exist yet, with nothing stored anywhere. Use `content` to check a diagram before you create it, and to check a single shape's text before you place it. Pass `docid` or `content`, never both, and `region` or `node`, not both; either crops `page`, or the first page. To preview a change to an existing board, use `board_preview_edit` instead — rendering an edited projection is not the same picture. Look at the image to judge the layout — overlaps, text outside its shape, crowded connector labels, uneven gaps, and shapes hidden behind another (a container drawn in front of what it holds: `reorder` it to `back`, or give it a lower `z_order`). The image is the check: nothing else in the answer says the layout is right. What to look for is in the `visual-design` guide (tool `guide_read`). If a picture on the board could not be drawn — unreadable bytes, too large to decode, or refused by the store — it is left out and `notes` names its res:// and why; an omitted picture looks like an empty shape, so check `notes` before you call one empty. One thing in this image differs from the board: the font family. This server draws every label in one built-in font; the text size, bold, italic, alignment, colours and every position are the board's own. The built-in font runs a little wider than the fonts boards use, so text that fits here fits on the board. If text clearly spills out of its shape, or a label runs past its connector, fix it: break it with `\n`, shorten it, or widen the shape (every shape of that role). Do not act on a line that is only slightly tight, and do not describe the board's typography from this image.

board_render

Unshare a Lekh board or folder: remove someone's access, or its public link. The person loses access immediately; say who you removed.

docs_revoke_share

Search the Lekh shape catalogue for a shape (stencil) to place on a board. Search with the plainest words for the thing — what it is, not what it looks like — and filter by `category` if you know it. Returns ids and metadata, never the drawing: you place a shape by its id and the server draws it. Matching is on words in a shape's name, id, library and keywords, ranked by relevance. Ids must be used exactly as given, and a few are historically misspelled (`avabodh.conatiner.rectangle`). A plain text label is `avabodh.basic.text` and a picture is `avabodh.basic.image`; neither is in this index, so use those ids directly rather than searching for them. Never invent a shape because search found nothing — narrow with `stencil_list_categories`, try a synonym, or tell the person it is not in the catalogue.

stencil_search

Share a Lekh board or folder with someone, at `read`, `write` or `comment`. Only the owner can share, and public link sharing works on boards but not folders. This gives a real person standing access to someone's work — confirm who and at what level before calling it, and say what you did afterwards.

docs_share_item

Star a Lekh board: add it to the person's starred list. Starred items are their own `view` in `docs_list_items`.

docs_star_item

Unstar a Lekh board: remove it from the person's starred list. Starred items are their own `view` in `docs_list_items`.

docs_unstar_item