Laver
This MCP server provides tools to read and drive Laver kanban boards, tickets, and the workspace wiki via the public REST API.
Workspace & Board Management
List accessible workspaces and boards (
list_workspaces,list_boards).Get board details including status columns, labels, members, and tickets (
get_board).Create boards, optionally from
crmorsales-leadstemplates (create_board).
Tickets — Reading & Search
List/filter tickets on a board with paging and
updated_sincepolling (list_tickets).Get full ticket details including
versionfor optimistic locking (get_ticket).Read ticket comments and activity history (
get_ticket_comments).Search tickets, boards, wiki pages, and comments across a workspace (
search).
Tickets — Modifying
Create tickets with title, markdown description, status, priority, and due date (
create_ticket).Update ticket fields (requires
version); label/assignee/custom field replacement is wholesale (update_ticket).Move ticket to another status column (
move_ticket).Add markdown comments (
comment_on_ticket).Archive tickets to 30-day recoverable trash (
archive_ticket); permanently delete trashed tickets (delete_ticket).Link tickets as
blocks/blocked_by(link_tickets); remove all links between tickets (unlink_tickets).
Attachments
List attachment metadata (
list_ticket_attachments).Fetch attachment content: text/CSV inline, images as image blocks, large/binary via
save_topath (get_ticket_attachment).Upload attachments from a file path or inline text (
upload_ticket_attachment).Delete attachments (trash 30 days, no restore tool) (
delete_ticket_attachment).
Wiki
List wikis, including archived wikis (
list_wikis).Full-text search within a wiki (
search_wiki).Get page tree with titles, UUIDs, nesting (
get_wiki_tree).Read page content and historical versions (
get_wiki_page,get_wiki_page_version).Create pages with markdown content and optional parent nesting (
create_wiki_page).Append markdown to existing pages; add-only, no conflicts (
append_wiki_page).Restore an archived wiki and its pages (
restore_wiki).
Automations
List automation rules on a board (
list_automations).Create live automation rules with triggers (events, schedules, due dates), conditions, and up to 20 actions; goes live immediately (
create_automation).
Limitations
No direct access to admin/account functions: cannot manage users, workspaces, public links, exports, bulk operations, or restore deleted attachments/trash generally, except archived wikis can be restored via restore_wiki.
@laver/mcp
An MCP server for Laver. Gives an agent tools to read and drive kanban boards, tickets and the workspace wiki.
Every tool is a thin call to the same public REST API the web app uses. There is no local state, no cache, and no second implementation of anything — if Laver refuses a write, the refusal comes back verbatim, because an agent can act on "409, re-read and retry" and cannot act on "something went wrong".
Setup
Create a workspace-scoped API key in Laver under Admin → API keys. It acts as the person who created it, so it can do exactly what they can do and nothing more, and it can be revoked without touching their account.
{
"mcpServers": {
"laver": {
"command": "npx",
"args": ["-y", "@laver/mcp"],
"env": { "LAVER_API_KEY": "your key here" }
}
}
}LAVER_API_URL overrides the API host; it defaults to https://api.laver.app.
LAVER_API_KEY_FILE is an alternative to LAVER_API_KEY: a path to either a
file containing nothing but the key, or a .env-style file with a
LAVER_API_KEY=… line among others (an assignment line wins; quotes and an
export prefix are both fine). That is how the .mcp.json in this repo
registers the server without a secret in a tracked file.
A file with neither — no assignment line, and more than one token in it — yields no key at all, and you get the "key is not set" error. It used to send the whole file as the token, which is fine for a file holding one secret and is a leak for anything else.
LAVER_API_URL must be https, except for localhost.
Working in this repo
.mcp.json at the repo root registers this server for anyone who opens the
project, reading the key from the gitignored .env. Nothing to export.
It runs the published package, npx -y @laver/mcp, rather than the
mcp/server.js beside it. That is deliberate: pointing it at the local file
meant everyone here ran the one code path no user takes, and that is precisely
how 0.1.0 shipped with an entry point that never connected its transport when
started through bin — which is the only way a real client starts it. Running
what we publish means we meet what users meet.
If you are editing this server, that same choice will fool you: your changes do nothing until they are published. Point the client at the working copy while you work on it —
{ "command": "node", "args": ["mcp/server.js"] }— and put it back before you commit. npm run check and
frontend/tests/check-mcp-bin-entrypoint.mjs both run against the working copy
regardless, so the tests never depend on a publish.
A client only connects to MCP servers at startup. claude mcp add while a
session is already running does not retrofit the tools into that session — the
tool list was built before the server existed. Start a new session (or
reconnect from the client's MCP panel) and the tools appear.
Related MCP server: acta
Tools
Reading
Tool | What it gives you |
| Where to start when you have no uuids |
| The boards in a workspace |
| A board with its status columns, labels, members and tickets |
| Tickets on a board, filterable, paged — |
| Triage across every board at once — |
| One ticket in full, its subtasks, including its |
| Comments and activity history |
| How long the ticket has spent in each column |
| A board's custom field definitions — the uuids |
| Every label in the workspace, not only the ones already used on one board |
| Boards, tickets, wiki pages and comments across a whole workspace at once |
list_workspace_tickets is the stand-up read: it needs no board_uuid, and it
is the only thing here that answers "what is late" and "what does nobody own"
without walking every board. It is deliberately the small sibling of
list_tickets — one page, 50 by default and 200 at most, no cursor — so narrow
it rather than paging it.
get_ticket_flow derives its numbers from the moves already in a ticket's
history. Read visits rather than the by_status totals if you are adding
several tickets up: tickets worked in one batch overlap, and their totals do not.
gaps says when the history and the ticket's current column disagree, which
makes the totals a floor rather than a measurement.
To follow a board, call list_tickets again with updated_since set to the
server_time the previous call returned; you get back the tickets that changed
and nothing else. There is no tool for the server-sent event stream at
GET /boards/:uuid/events — a tool call is one request and one answer, and a
stream that never ends is neither.
Asking for less. A tool result is charged against the model's context, and
three of these calls are the ones you cannot route around: a status_uuid or a
label_uuid comes from get_board, and a page_uuid comes from
get_wiki_tree. On a busy board they were 154 kB, 119 kB and 180 kB. Each now
takes a parameter that narrows the reply, and every one of them is opt-in — a
call that passes none of them is unchanged.
Call | Gives you | Measured |
| the structure alone — statuses, labels, fields | 155 kB → 17 kB |
| the top level, nothing nested under it | 119 kB → 1.8 kB |
| one page and everything beneath it | 119 kB → 9.8 kB |
| titles and uuids without the bodies | 167 kB → 45 kB |
Reach for get_board(include_tasks: false) whenever you called it for a uuid
rather than for the tickets, and list_tickets when you want the tickets —
that one takes status and limit as well.
Writing
Tool | Notes |
|
|
| Needs |
| Needs |
| Markdown in |
| Your own comments only; replaces the whole body and is marked as edited |
| Your own comments only; to the trash, and nothing here restores one |
| Clears this ticket's unread badge for the user the key acts as |
| One checklist item, appended — plain text, not markdown |
| Tick it off ( |
| Not recoverable — a checklist item has no trash |
| To the trash — recoverable for 30 days |
| Destroys one already in the trash — permanent |
| Optionally from a template — |
| "this before that" — direction is |
| From either end, and removes every kind of link on the pair |
Comments are not versioned, so none of the three comment writes takes a
version and none of them can 409 — the last edit wins. Only the author may
edit or delete one, and somebody else's is a 404 indistinguishable from a
comment that does not exist, so these never report who wrote what.
get_ticket_comments deliberately marks nothing read; mark_comments_read is
the only call that does, and it marks up to the newest comment that exists at
that moment rather than subscribing.
Subtasks are the checklist on a ticket — a progress count on the card, and where
acceptance criteria belong when they are meant to be ticked off one at a time.
get_ticket returns the items themselves, so there is no separate list tool.
Board structure
Tool | Notes |
| A new column, appended to the right-hand end |
| Rename, recolour, or set |
| The complete list of uuids, in order; a stale list is a 409 |
| The column must be empty, and a board keeps one |
| A swimlane; there is no rename route, so a wrong name is deleted and remade |
| Same complete-list contract as |
| Tickets in it survive, ungrouped — and their versions all move |
| Workspace owner or admin; |
| Rename, reorder, or replace a select's whole |
| Takes every ticket's value in that field with it — no trash, no restore |
This is what a board an agent creates needs to stop being its template's
defaults. The two reorder tools want the whole list because a partial one is how
two simultaneous reorders silently drop a column: read the uuids off get_board
immediately before calling, and re-read on a 409.
Labels
Tool | Notes |
| Workspace-wide, alphabetical — |
| A hex colour is required; names are unique ignoring case and space |
| Renames it everywhere — one label, not a copy per board |
| Removes it from every ticket that carries it |
A label is a workspace object shared by every board, which is the thing to be
sure of before renaming one: it changes for everybody. The uuids these return
are what update_ticket takes as label_uuids.
Attachments
Tool | Notes |
| Name, type, size and uuid — never the bytes |
| Text inline, an image as an image block, anything else via |
|
|
| To the trash for 30 days; there is no restore tool |
get_ticket reports attachment_total, so you know whether listing is worth a
round trip.
Binary content crosses the tool boundary by not crossing it. A tool result
is text, Laver allows 25 MB per file, and 25 MB of base64 is roughly nine
million tokens — so only text, CSV and images under 4 MB come back inline, and
everything else needs save_to, which writes the file to a path on the machine
running this server (normally the agent's own, since the client starts it as a
subprocess). Uploads go the same way round: file_path reads from that machine
and costs no context.
An image comes back as an MCP image block rather than as text, which is the only form a model can actually look at — that is the whole point of the tool, since the screenshot somebody attached is usually the specification.
Wiki
list_wikis, search_wiki, get_wiki_tree, get_wiki_page,
get_wiki_page_version, append_wiki_page, update_wiki_page,
create_wiki_page — which takes the body as markdown and nests under
parent_page_uuid — and restore_wiki.
Archiving a wiki (done in the browser; there is no tool here for it) takes it
and every page under it out of list_wikis entirely. list_wikis takes
archived: true to see those instead — the only place an archived
wiki_uuid is visible at all — and restore_wiki is the only thing here
that does something with one: it un-archives the wiki, and every page under
it, in one call.
get_wiki_page_version is how you read something that was overwritten. It is a
read: the page does not move. There is deliberately no tool to put an old
version back — read it and write the wording you want with update_wiki_page,
which leaves a version of its own behind.
append_wiki_page adds to the end of a page and update_wiki_page replaces
what is on one; prefer the first when you are adding, because it takes no
version and two agents appending at once both get their text. Replacing takes
the version from get_wiki_page, and a page somebody wrote to meanwhile is a
409 carrying the current version rather than an overwrite — the guard that lets
this exist at all, since wiki pages sit behind a live collaborative editor. A
replace re-seeds that editor from what it just wrote, so a colleague with the
page open sees the new text instead of putting the old text back, and every
previous save stays readable through get_wiki_page_version. There is still no
tool to delete a page.
The markdown goes through the same parser ticket descriptions do. Headings,
lists, tables, code blocks, blockquotes, rules and links survive; so does an
 image, as a reference to that URL — there is no tool here to
upload an attachment, so the URL has to be public already. Raw HTML is kept as
literal text rather than interpreted.
Automations
Tool | Notes |
| The rules on a board, each with its |
| One rule in full — the conditions and actions an edit replaces |
| What a rule has actually done, newest first |
| Owner or admin only — and see below before calling it |
| Needs |
| Needs |
An automation rule is a trigger, optional conditions and up to twenty actions, stored against a board. Three things about them are worth knowing before an agent touches these tools:
A rule created here is live immediately. It fires on its trigger within a couple of seconds, so read
list_automation_runsafterwards rather than creating one speculatively to see what it would do.A rule is a standing grant. It runs as the user this key acts as, every time it is triggered, for as long as it exists — not once, like every other write in this server. Revoking the key does not stop it; disabling or deleting the rule does.
Pause before you delete.
update_automationwithenabled: falsestops a misbehaving rule at once and keeps its history; deleting destroys the history along with the rule.conditionsandactionsreplace the stored lists rather than merging into them, so build them fromget_automationand not from memory.
Both writes take the rule's version and answer 409 with the current one, the
same contract ticket writes have.
Published links
list_published_links is the inventory read: what of this workspace's is on the
public internet right now, each row with its share token, who published it, when,
and how many strangers have looked. live is what a stranger actually gets and
dark_reason says why a row is not, which is the only way to find a published
page that is currently archived and would go straight back online if somebody
restored it. Workspace owner or admin only; an ordinary member is a 403. Taking
a link back down is deliberately not a tool — report what is published and let a
person decide what comes off.
Not covered
The REST API is larger than this server, and the difference is deliberate rather
than accidental — mcp/route-coverage.js lists every backend route with either
the tool that calls it or the reason it has none, and npm run check fails if a
route appears that is in neither. That is what keeps this section true: it went
stale before, silently, which is how the server spent its whole life unable to
read a ticket's attachments while every check stayed green.
Not yet — wanted, not built:
Notifications. Still the biggest gap, and now blocked on something a tool cannot fix: an agent cannot see that it was mentioned or assigned, and
backend/notifications/index.jsinstallssession_onlyon the whole plugin, so every route there answers a key with a 401 however good the tool is. Adding one means first deciding whether a key may read its owner's inbox at all — a surface carrying other people's messages — which is a product and security call rather than a delivery task.list_workspace_ticketscovers the triage half and is the closest substitute meanwhile.Listing subtasks on their own. Needs no tool rather than lacking one:
get_ticketalready returns the checklist items themselves — uuid, title and done state — so a dedicated list route would be a second way to ask the same question. Writing them is covered.Board templates. A workspace can save one of its own boards as a template and start the next board from it. Listing them has no tool, which is what keeps the saved ones out of reach:
create_boardnames the two built-in ids in its schema, and a saved template's id is a uuid nothing here can discover. Saving and deleting are deliberately absent rather than pending — a template is workspace-wide furniture in everyone's board-create form, and adding to or removing from that list is a decision taken in front of the board.Attachment thumbnails. Deliberate, not a gap. The thumbnail route serves the web client a downscaled webp so a card cover costs kilobytes instead of megabytes; an agent wants the file somebody actually uploaded, and
get_ticket_attachmentalready returns that at full resolution in its original format.Where you left off. The five things the ⌘K palette offers a person before they type anything — the tickets and pages they last opened or worked on. Work done through a key is kept out of it on purpose, so a tool here would ask which tickets its owner had been reading;
list_workspace_ticketsis the better answer to what to pick up, andsearchto anything more specific.Board analytics. A small loss now that the triage half is covered by
list_workspace_tickets. What is left is shaped for charts rather than for a decision: stats and board-wide flow are aggregates a person reads on a screen, activity is a feed, search-text serves find-as-you-type, and export hands back a file.get_ticket_flowcovers the one figure an agent acts on, per ticket, where it can be attributed.The wiki page a board is about. Deliberate, because every part of the answer is already reachable and the route is only the join.
get_boardreturns the board'swiki_page_uuid, andget_wiki_pageandget_wiki_treeread that page and everything under it with the same access rules and more of the content. The route exists so a person looking at a board can reach the handbook without remembering its name; an agent holding the uuid needs no such shortcut.A conductor's scoreboard. Never, and not for want of the tool being easy. The route reads back how the tickets one person wrote fared once an agent picked them up, for that person alone; an agent reading the scores of the people briefing it is the wrong way round, and one that could read them could play to them.
Pressing an automation button. Deliberate rather than pending: a
manualrule exists so that a person decides when it runs, and a tool that pressed it would hand that back. Creating one is the safe half and is covered.Ticket history, duplication and recurrence.
Sprints. Blocked in the same place notifications are:
backend/sprints/index.jsinstallssession_onlyon the plugin, so a key gets a 401 from every route there —POST /boards/:uuid/sprintsincluded. Opening them to keys is a decision about what a key may do to a team's planning cadence (a rollover migrates every unfinished ticket onto a new board), not a matter of writing the tools.Deleting and rearranging a wiki page. Editing one is covered now, by
update_wiki_page; archiving, moving and duplicating are not, because they change what a colleague can find rather than what a page says, and a page nobody can find has no version history to consult. Removing a whole wiki (DELETE /wikis/:wiki_uuid, which archives it and every page under it) is in the same group: it takes a wiki's published pages off the internet in the same instant it archives them, which is consent, not editing. Its restore route is covered instead, byrestore_wiki, now thatlist_wikiscan find an archived uuid to give it.Commenting on a wiki page. Uncovered because of the anchor rather than the shape of the call. A comment there is attached to the words it is about — the quote, and which occurrence of it — because a page is edited collaboratively and a stored document position comes to mean different text the moment a colleague types above it; the client re-finds that quote in the document it has just rendered. An agent holds no document, so it would be sending a quote it believes is on the page, and the failure it hits most is silent: a phrase that appears twice, counted differently at the two ends, anchors the remark to the wrong sentence. A tool worth having would take the page and the quote and say plainly when the quote was not found, which is the right next job if agents are ever asked to review pages. Until then a key already has the honest way to say something about a page:
append_wiki_pageandupdate_wiki_pageput it IN the page, where the people reading it will see it, rather than in a margin no other tool can read back. Editing, withdrawing and resolving follow from that — there is nothing for a key to edit while it cannot comment — and resolving in particular takes the highlight off somebody else's prose and declares a conversation between people finished. Reading the thread is uncovered on its own merits: those comments are a discussion about a draft, and an agent asking what a page says wantsget_wiki_page.Imports and feedback forms.
Not ever, from a key:
Reporting a deployment.
POST /tasks/:task_uuid/deploymentsis how a build pipeline tells Laver that a ticket's pull request reached an environment or failed to, so the people assigned to it are told. The caller is a CI job holding a key in a secret, at a moment when no model is running; a tool over it would let an assistant announce a deployment no pipeline performed, and the whole worth of the notification is that it reports a fact rather than a claim. The reading half an agent might want it already has: the deployment is a ticket event, soget_ticket_flowand the timeline carry what happened, when, and which key said so.Reporting a merged pull request.
POST /tasks/:task_uuid/pull-requests/mergedis the same bargain: a CI job says the ticket's pull request was merged, and the board moves the ticket into the column tagged for merges. A tool would be a second way to move a card — an agent hasmove_ticket— differing only in that it also writes "this ticket's pull request was merged" onto the timeline, which an assistant that merged nothing has no business claiming. Reading is covered: the merge is a ticket event, soget_ticket_flowcarries it.Public links and publishing. Publishing turns something private into something anyone with the URL can read. That is consent, and a tool call is the wrong shape for it.
Taking a published link back down. The read shipped and the two DELETEs did not, which is the same split: a tool cannot carry consent, and that says nothing about ASKING what is public.
list_published_linksanswers the question and grants no power the caller did not already have, since every link it names is public by definition. Retracting one is a bounded admin power exercised in front of a screen showing what is about to go dark, so an agent reports the inventory and a person decides what comes down.Asking a person for their signature. Refused at the route rather than merely unbuilt: all three answer a key with a 401 before they read anything. Sending a request puts a message into a stranger's inbox carrying our SPF and DKIM, and the judgement that an address deserves to be asked for a signature is a person's — a key acts as whoever minted it and would inherit their edit access, so permissions would not stand in the way. Listing the outstanding requests is the dialog's own read, returning them beside the sections computed from the live document they may attach to, and
get_wiki_pagealready carries the text. Withdrawing one is the same judgement from the other side.Taking a board away, and how it looks. The structure half of this group is covered — statuses, groups and custom fields all have tools. What is left is removal and decoration. Archiving and deleting a board are one write under two names, and a tool over either would let a key take a whole board and every ticket on it out of the workspace's view in one call; restore is uncovered as a consequence, since nothing an agent can do archives a board and
list_boardsdeliberately cannot find an archived uuid. Permanent deletion is firmer still — the row, its tickets and their attachments' bytes all go — and is a person's decision made twice, from a screen showing what they are about to lose. The board's colour and background picture are decoration chosen while looking at the board, which is the one thing an agent cannot do. A column's entry requirements sit here too: the read needs no tool, becauseget_boardalready sends each column'sentry_requirementsand a refusedmove_ticketnames every one the ticket does not meet — but a key that could set them could remove them and then move the ticket, so the gate would only be as strong as the weakest tool over it.Moving a board between workspaces. Not a judgement about blast radius — a key cannot make this call at all. A key is confined to the one workspace it was issued for, and
POST /boards/:board_uuid/move-workspacenames two: the workspace the board is in, and the one it is going to. A tool over it would need a key that reached both, which is the confinement gone, or it would refuse every call it was ever given. The gesture is not an agent's either: an admin of two workspaces decides which of them a whole board — its tickets, comments, attachments and history — belongs to, and the route requires owner or admin in both ends before it moves anything.Workspace and membership administration. A key acts as the person who created it; renaming or deleting their workspace, or answering an invitation for them, reaches further than delegating a board task ever meant.
The whole-workspace export.
POST /workspaces/:uuid/exportsand the routes beside it build one file holding every ticket, comment and wiki page in the workspace, and they refuse a key before looking at anything else. A key in a CI variable that could ask for one turns any leak of it into a full data breach rather than the scoped access it was issued for. Taking a copy of the company's data is a thing a person does, signed in, from Admin, and the audit trail records which person.Bulk ticket writes.
POST /tasks/archivebins a list in one call.archive_ticket, one at a time, is the deliberate choice.Trash. One-way on purpose: an agent can archive and can destroy what it already archived, and a person puts things back.
The board event stream. Server-sent events; a tool call is one request and one answer.
list_ticketswithupdated_sinceis the replacement.Scheduler endpoints. The deployment's own cron hooks.
Removing a ticket
Two steps, deliberately, so that nothing is destroyed by a single call:
archive_ticket task_uuid → the workspace trash, recoverable for 30 days
delete_ticket workspace_uuid + task_uuid → gone, and nothing brings it backdelete_ticket refuses anything that is not already archived, so the order is
enforced by the server rather than by convention. There is no restore tool here
— a ticket in the trash is put back from the web app — so treat
archive_ticket as the furthest you can go on your own.
Read the ticket before you archive it if you intend to destroy it:
delete_ticket needs the workspace_uuid, get_ticket is where you get one,
and an archived ticket can no longer be read.
Working out what to do next
Every ticket read carries blocked_by, blocks and is_blocked. is_blocked
is false once every blocker has reached a completion column, so the tickets a
board is ready for are the ones where it is false. link_tickets records the
dependency; a link that would make a loop is refused with a 409, because a loop
makes the ordering unanswerable.
The one rule worth knowing
Tickets carry a version. Every write must send the version you read, and a
write against a stale one is refused with 409 rather than silently
overwriting whoever got there first. The server turns that into an instruction,
and Laver's refusal carries the current version, so the instruction can include
it rather than spending a second call on it:
Laver 409: Task was updated by another request.
Somebody wrote first, so the version you sent is stale. The current version is 12. If your change does not depend on what you read — moving a ticket to a named column, say — retry with that version. If it does, call get_ticket again and decide against the ticket as it now is, or you will quietly undo the other write.
Read, then write. Do not cache a version across a long turn.
When the key is refused
A 401 is the key: missing, mistyped, revoked, expired, or a placeholder that was never filled in. The underlying message is not always a fair description of what happened — a key the JWT layer cannot parse comes back as "Authorization token is invalid: The token is malformed", which sounds like a corrupted string when the usual cause is simply a key that was replaced. The server appends what to do about it, including the part that catches people out:
An MCP client reads that environment once, when it starts this server, so it must be restarted afterwards — editing the config in a running session changes nothing.
A 403 is different and is never worth retrying: the key was accepted, and then refused this particular action. It is scoped to another workspace, or the person it acts as has a read-only role, or is a guest without access to that board.
The key itself is read in exactly one place, sent as a bearer token, and never logged, echoed, or included in any error text.
Checking it
node check.js # schema, then every read-only tool actually called
node check.js --require-live # …and a skipped sweep is a failure, for CI
# the same calls against the API the published package actually talks to
LAVER_API_KEY_FILE=../.env node check.js --live-apiTwo halves. The first is static: every tool registered, classified read or
write, described, and given a schema. The second boots the backend from
../backend on a spare port, creates a workspace of its own, mints a key
against it, and calls every read-only tool — through the tool's own zod
schema and then its handler — sending every parameter the tool declares.
That half exists because the first one passed while list_wikis sent
?workspace= at a route that requires workspace_uuid. It 400'd on every call
it ever made, and since it is the only tool that yields a wiki_uuid, the whole
wiki half of this server was unreachable from the day it shipped — with
registration, descriptions and schema shape perfect throughout.
It needs the same things npm test in backend/ needs: that directory, its
node_modules, its .env, and the Postgres they point at. No API key and no
network beyond localhost — a real LAVER_API_KEY in the environment is ignored.
Without a backend it prints a banner saying the tools were not called and
runs the schema half alone; --require-live turns that into a failure.
It is only as local as backend/.env is, though. Running it writes to
whatever database that file points at: it creates a workspace, a board, two
tickets, a comment, a wiki, a page and an API key, and deletes them again at the
end. It also loads the backend into its own process. It listens with
app.server.listen rather than app.listen — the same idiom the collab and
board-events integration tests use — so Fastify's onListen hooks do not fire
and none of the seven schedulers start; without that, the billing sweep alone
would run against every workspace in that database. Point backend/.env at
staging and this is a check that writes to staging.
The sweep is read-only and stays that way: a check that creates tickets in
somebody's workspace every time it runs is a check people stop running. The
write tools are covered by the schema half only — see the note at the foot of
check.js for the way to cover them without sending a write.
Ctrl-C is safe. The sweep stops after the call in flight and the fixture workspace is deleted before the process exits; a second Ctrl-C kills it outright if the call in flight is the thing that is stuck.
Against the deployed API
--live-api points the same calls at LAVER_API_URL — https://api.laver.app
unless you say otherwise — with a real key, taken from LAVER_API_KEY or from
the file LAVER_API_KEY_FILE names, exactly as the server itself takes it.
It exists because a green local run and a working published package are two different claims. The local sweep proves the tools agree with the code in front of you; this package talks to the deployed API, so a route that ships a rename before the package does breaks every agent in the field while the local sweep stays green. That is a narrow window — the tools and the routes live in one repo and move together — but it is exactly the window publishing to npm opens.
Both modes run the same table, in cases.js, and every case carries an
expectation for each: exact counts locally, where the fixture is known, and
shapes and invariants live, where the workspace is somebody's real one and
cannot be seeded or torn down. A case with only one of the two is a failure, so
a new call cannot cover one transport and skip the other.
It creates nothing and deletes nothing, and that is enforced rather than
promised: live mode replaces fetch with one that refuses any method but GET,
so a write tool called by mistake cannot reach the network at all.
frontend/tests/check-mcp-live-api-mode.mjs runs the whole mode against a stub
API and asserts that every request that left the process was a GET.
Instead of a fixture it goes looking for something to point at, and wants a board with at least two tickets in at least two columns, in a workspace with a wiki that has a page. It refuses to run against anything thinner rather than passing quietly: a filter case against an empty board passes whether or not the filter was applied, which is the failure this whole file exists to prevent.
Opt-in, and never part of npm run check:all or CI — it needs a key and a
network, and neither belongs in a check that runs on a box with no secrets.
Publishing
0.1.0 is published and is broken. Do not tell anyone to install it. It
starts, registers all 20 tools, connects no transport, and exits 0 without
writing anything to stdout or stderr — so a client sees the process end and
nothing else. The entry-point guard compared the basename of process.argv[1]
against this file's name, which is true only for node mcp/server.js; npm's
shim for bin makes argv[1] node_modules/.bin/laver-mcp, so npx -y @laver/mcp — the way this README tells everyone to run it — never matched.
Fixed in 0.1.1, and tests/check-mcp-bin-entrypoint.mjs now spawns the server
through a symlink and speaks MCP to it, so the same class of bug cannot ship
again.
When 0.1.1 goes out, mark the broken one so nobody lands on it:
npm deprecate @laver/mcp@0.1.0 "Never connects its stdio transport when run via npx or the bin shim. Use 0.1.1 or later."Unpublishing 0.1.0 is the other option and is worse: within 72 hours it removes the version, but the number stays burned either way, and anything that already pinned it breaks rather than being warned.
The publish itself is the owner's to run, because it is public, permanent enough to matter, and takes a name nobody else can then have.
The name. laver on npm is taken — v1.0.0, published in 2021 by an
unrelated maintainer — so the bare name is not available and never will be.
This package is therefore @laver/mcp: the brand name kept as the scope,
with the generic part where it belongs. Checked against the registry on
6 Aug 2026 — @laver/mcp is free, and nothing has ever been published under the
old unscoped laver-mcp, so the rename costs nothing.
The scope exists and the first publish has happened. 0.1.0 and 0.1.1 are
on the registry under @laver/mcp, created 2026-08-06T22:14Z — which is the
only proof that matters that the scope resolves and the publishing account may
write to it. This paragraph used to say the scope did not exist yet; that was
true when it was written and is not now.
Do not re-test it with https://registry.npmjs.org/-/org/laver. That URL is a
404 unauthenticated whether the org exists or not, so it cannot tell the two
apart — read the package document instead:
curl -s 'https://registry.npmjs.org/@laver%2Fmcp' | python3 -m json.toolFor a self-hosted fork publishing under its own scope, the first publish still
needs that scope created at https://www.npmjs.com/org/create (free for public
packages) or confirmed as the account's own username, with npm whoami to
check membership. npm publish fails with
404 Not Found - PUT https://registry.npmjs.org/@<scope>%2fmcp if the scope
does not exist, which reads like a network fault rather than a missing org.
The executable stays laver-mcp. The package is @laver/mcp, but bin is
deliberately not renamed to mcp: a global install would put a command called
mcp on the PATH, which is far too generic and collides with every other MCP
server anyone installs. npx -y @laver/mcp works regardless — npx runs the
package's only bin whatever it is called — so nothing in the config snippet
above depends on the command's name.
repository and bugs point at the public mirror. They were absent while
github.com/Developyn/laver was the only home — it is private, npm renders both
fields as links on the package page, and aiming the only two "where does this
come from" links at a 404 is worse than having neither. Since August 2026 the
published files are mirrored to github.com/Developyn/laver-mcp, which is
public, so both now resolve. Note there is no "directory" key: the mirror's
root is the package, whereas here the same files live under mcp/.
The mirror is what every MCP directory anchors a listing to, so it has to keep
up. After each publish, copy the published tarball's contents over it —
npm pack @laver/mcp && tar xzf laver-mcp-<version>.tgz — and commit. Its
Dockerfile, glama.json and CI workflow are mirror-only and are not in
files, so they never ship to npm.
mcpName is for the official MCP registry, which matches the package
against the server name being published there. It must equal the namespace
mcp-publisher login github actually grants you — io.github.developyn/… if it
authorises the org, io.github.melvyn-developyn/… if only the personal account.
Getting it wrong is not fatal, but correcting it costs another version.
Before each one
2FA on the publishing account, if it is set to require it for publishing (npm enforces this for some accounts and packages and prompts for others). Passing
--otpsaves a prompt from failing a non-interactive run; drop it if not enrolled.npm whoamianswering with that account —npm loginif not.For CI instead of a laptop: an automation token in
NPM_TOKEN(granular, write-scoped to this package). Automation tokens bypass the 2FA prompt, which classic read-write tokens do not.A version the registry does not already have. npm refuses to republish an existing one, so this is not tidying — it is what makes a publish possible at all. Check what is live first, because the repo's number and the registry's can be equal while the contents differ, and nothing warns you:
npm view @laver/mcp version. Minor for new tools, patch for fixes to existing ones.
The publish
cd mcp
npm ci # the lockfile, not whatever resolves today
npm run check # schema + every read-only tool actually called
npm pack --dry-run # confirm the file list is LICENSE, README.md, package.json, server.js
npm publish --access public --otp=<code-from-your-authenticator>
npm cideletes and reinstallsmcp/node_modules. In the shared development checkout that directory is shared with every agent running against it, and removing it mid-run breaks their tests — which is why the agent instructions forbid it and why an agent preparing a release stops before this block. It is correct and expected for whoever actually publishes; just do not run it while others are working in the same tree.
--access public is required here: scoped packages default to restricted,
and a restricted publish on a free account is refused outright. publishConfig
in package.json already sets it, so the flag is belt and braces rather than the
only thing standing between this and a private package.
Afterwards
npx -y @laver/mcp # should start and wait on stdio, not exit
npm view @laver/mcpA mistake is recoverable only briefly: npm unpublish @laver/mcp@<version>
works within 72 hours, and the version number is burned afterwards regardless.
The package name is not returned to the pool by unpublishing a version.
Licence
MIT — see LICENSE, which ships in the package.
Available Tools
30 toolsappend_wiki_pageA
Add markdown to the END of a page that already exists. This is the tool for writing what you learned into your own section of a shared page — the thing create_wiki_page cannot do without leaving you a second page of the same name. It ADDS ONLY: it cannot change or remove a word that is already on the page, which is exactly why it is safe to offer where a general edit is not. There is still no tool to edit or delete existing content; if you need to correct something you appended, append the correction. Takes NO version and never conflicts — two agents appending to the same page at the same moment both get their text, in whichever order the server serialises them, and neither is asked to retry. Markdown is converted server-side by the same parser create_wiki_page uses, so headings, lists, tables, code blocks and links all survive; lead with a heading if you want your section to be findable. The reply is the page's identity and its new version, deliberately NOT the page body — appending does not need you to have read the page, and getting the whole document back is the cost this tool exists to avoid. Markdown that is only whitespace is a 400 rather than a version bump for no change. Needs write access to the workspace: a read-only role or a guest key is a 403 and retrying cannot fix it.
Inputs: page_uuid (required), content_markdown (required).
archive_ticketA
Move a ticket to the workspace trash — the recoverable half of deleting. It leaves the board, stops appearing in list_tickets and search, and get_ticket answers 404 for it, but it can be restored for 30 days from the workspace's trash in the web app, and is destroyed automatically once that window passes. This server has no restore tool, so from here archiving is a door only a person can reopen. It takes no version and cannot 409 — archiving is not a field edit, so there is nothing to conflict with. Already archived, never existed, and on a board you cannot open are all the same 404, so a retry is safe and a 404 tells you nothing about tickets you cannot see. If you intend to destroy the ticket permanently, call get_ticket FIRST and keep its workspace_uuid: delete_ticket needs one and an archived ticket can no longer be read to find it.
Inputs: task_uuid (required).
comment_on_ticketA
Add a comment to a ticket. Markdown in body is parsed — headings, lists and code fences all render. Comments are not versioned: this takes no version and cannot 409, so it is the one write that is always safe to make against a ticket somebody else is editing, and it is the right way to report something rather than editing the description out from under them. It is also the write a read-only key can still make — a commenter role is refused update_ticket and move_ticket with a 403 but allowed this. A ticket you cannot open is a 404. Posting does not mark the thread read on your behalf.
Inputs: body (required), task_uuid (required).
create_automationA
Create an automation rule on a board from a trigger, one to twenty actions, and optional conditions. READ THIS BEFORE CALLING IT: the rule runs as the user this API key acts as, every time it is triggered, for as long as it exists — a standing grant of that person's permissions to anybody who can cause the trigger, not a one-off write like every other tool here, and the resulting history is attributed to them. This one takes effect immediately: the rule is live as soon as it is created and fires on its trigger within a couple of seconds, so do not create one speculatively to see what it would do. Creating one requires a workspace OWNER or ADMIN — a member who can otherwise write on the board is a 403 and retrying cannot fix it. A 402 means the plan's per-board rule limit is already reached (two on free) and nothing was created. Conditions are a flat AND of field/operator/value tests and every one must hold; the operators a field accepts differ, so title contains x is valid where title is x is a 400 listing the operators title takes. run_as_user_uuid defaults to the key's own user, and naming somebody else is refused unless they are an active member who can write and can see the board. Rules arrive switched on unless you pass enabled: false. The schedule and ticket.due triggers are not events and REQUIRE trigger_config: a schedule fans out over every ticket the conditions select at its appointed time, in UTC, so give it conditions unless you really mean the whole board; a due-date rule fires once per ticket per threshold and never retroactively, so creating one does nothing to work that is already overdue. column.empty is the odd one: it is about ONE ticket rather than the board, so it requires a task_uuid alongside trigger_config: {status_uuid}, and it fires the moment that column holds nothing — which may be the moment you create it, since a column that is already empty is already empty. It also keeps doing it every time that column empties again, for ever, unless you pass run_limit; one-off queue entries are what people usually mean, so pass run_limit: 1 unless a standing arrangement was actually asked for. create_linked_ticket is the exception to all of that: it CREATES a ticket rather than changing the triggering one, it needs a title (templated, so {{now}} makes a weekly checklist a new ticket each week) and takes an optional description, status_uuid and relationship (blocks, blocked_by, related_to, duplicate_of, stated from the new ticket's point of view). A schedule rule whose actions are ONLY this fires once for the board rather than once per ticket, which is what makes "every Monday, create the release checklist" work — and such a rule is refused if it also carries conditions, a relationship, or any action that acts on a ticket, because none of those has a ticket to be about. A ticket-triggered rule using it feeds itself, and is stopped by the depth cap after three chained runs rather than looping.
Inputs: name (required), actions (required), board_uuid (required), trigger_type (required), +6 more.
create_boardA
Create a board in a workspace. Without template the board arrives with Laver's default columns; with one it is seeded with that template's columns, labels and a few example tickets. template accepts exactly "crm" or "sales-leads" — anything else is a 400 from the schema, so do not guess an id. A template applies once, at creation: there is no way to apply one to an existing board and no link back afterwards, so a board created without one has to be arranged by hand. A workspace you cannot open is a 404, and a 402 means the plan's board limit is already reached and the board was not created — neither is worth retrying.
Inputs: name (required), workspace_uuid (required), template.
create_ticketA
Create a ticket on a board. Give either status (the column name) or status_uuid; with neither it lands in the first column. Markdown in description is parsed — headings, lists and code fences all render. It is appended to the bottom of its column unless you send a position. The reply is the new ticket, including the uuid to reference it by and the version any later write to it will need, so there is no need to re-read it before your next call. This tool sends no idempotency key, so calling it twice makes two tickets: on a timeout or an unclear failure, use list_tickets with q set to the title to see whether the first one landed before you retry.
Inputs: title (required), board_uuid (required), status, due_date, +4 more.
create_wiki_pageA
Write a NEW page into a wiki, with its body as markdown. This is how an agent puts findings somewhere durable instead of handing them back as chat text. wiki_uuid comes from list_wikis; parent_page_uuid (from get_wiki_tree) nests the new page under an existing one and is where a page belongs unless it is genuinely top-level. The markdown is converted server-side by the same parser ticket descriptions and comments go through — headings, lists, tables, code blocks, blockquotes, horizontal rules and links all survive. An  image survives too, as a reference to that URL — but only for a URL already hosted somewhere public, because there is no tool here to upload an attachment, and an image the reader cannot fetch renders as a broken one. Raw HTML is kept as literal text rather than interpreted, so do not reach for it to get something markdown lacks. ADD ONLY: there is deliberately no tool to change or delete what is already on a page. Wiki pages have a live collaborative editor behind them, so a whole-document overwrite from here would silently destroy whatever a person had open at the time. Adding cannot damage anything, so it is offered and overwriting is not. Do not call this twice to 'update' a page; you will get two pages — to add to a page that already exists, use append_wiki_page. Creating a page needs write access to the workspace: a read-only role or a guest key is a 403 and retrying cannot fix it. A title is required and a body is not, so a page can be created empty and filled in by a person later.
Inputs: title (required), wiki_uuid (required), content_markdown, parent_page_uuid.
delete_ticketA
Permanently destroy a ticket that is ALREADY in the trash, along with its comments and attachments. Nothing undoes this — not the trash, not a restore, not support. It is the second step and never the first: archive_ticket, then this. A ticket still live on a board answers 404 rather than being destroyed, so this cannot bin something in one call. workspace_uuid must be the workspace the ticket belongs to — from get_ticket before it was archived, or get_board for the board it was on. Naming a workspace your key was not issued for is a 403 (This API key is scoped to a different workspace.) and never reaches the ticket; naming your own workspace for a ticket that does not live in it is a 404. Keep this for tickets that should never have existed: a duplicate, a probe, a test fixture you created. Anything a person might want back can simply be left archived, where it expires on its own. The 404 is otherwise deliberately undistinguished — not archived, already destroyed, and a board you cannot open all look identical.
Inputs: task_uuid (required), workspace_uuid (required).
delete_ticket_attachmentA
Remove a file from a ticket. This is the same one-way-but-recoverable move archive_ticket makes: the attachment leaves the ticket immediately and its bytes sit in the workspace trash for 30 days, after which the sweep destroys them. There is no tool here to restore one — that is the web app — so treat it as final in an agent's hands. The freed bytes stop counting against the workspace's storage quota straight away. An attachment already deleted, still uploading, or on a ticket this key cannot open are all the same 404, so this never confirms that a file existed.
Inputs: task_uuid (required), attachment_uuid (required).
get_boardA
A board with its status columns, labels, members and tickets. The status uuids returned here are what create_ticket and move_ticket expect. Each ticket carries label_uuids — bare uuids, resolvable against the board's labels list in the same reply — which is exactly the field update_ticket takes, so a label read from here can be written straight back without remapping. Note that list_tickets and get_ticket still return expanded labels objects, because neither reply has the dictionary to resolve uuids against. The tickets are around 90% of this reply, so pass include_tasks: false when you came for the uuids.
Inputs: board_uuid (required), include_tasks.
get_ticketA
One ticket in full: its fields, its subtasks, its expanded labels objects, and the version every write needs. Read this before you write. update_ticket, move_ticket, archive_ticket and the rest all take that version and answer 409 if it has moved on since you read it — that 409 is the signal to call this again and retry against the fresh version, never to drop the version or force the write. labels arrive expanded rather than as bare uuids because this reply carries no board dictionary to resolve them against; get_board returns label_uuids instead, and that bare-uuid shape is the one update_ticket wants. A ticket you cannot open answers 404, the same 404 as one that never existed, so a 404 here is not proof the ticket is gone.
Inputs: task_uuid (required).
get_ticket_attachmentA
Fetch one attachment's CONTENT, having found its uuid with list_ticket_attachments. What comes back depends on what the file is, because a tool result is text and most files are not: a text or CSV attachment is returned inline as text; an image is returned as an image block, which is the only form the model can actually look at; anything else — a PDF, a spreadsheet, a document — cannot cross this boundary as text at all, and needs save_to. Pass save_to for any file you want on disk, and for anything large: it writes the bytes to that path on the machine THIS SERVER runs on (normally the same machine as the agent, since the client starts it as a subprocess) and returns the path and size instead of the content. Files over 4 MB always need save_to, whatever their type, because an inline result that size costs more context than the answer is worth. Missing, still uploading, deleted, or on a ticket you cannot open are all the same 404.
Inputs: task_uuid (required), attachment_uuid (required), save_to.
get_ticket_commentsA
The discussion on a ticket, as two lists: comments — the thread, oldest first — and events, the activity history the web app draws alongside it (moves, field edits, who did what and when). The whole thread comes back in one call; there is no paging and no cursor, so a very long one is simply long. Reading is free of side effects: it does NOT mark the thread as read or clear anyone's unread badge, so polling this to follow a ticket cannot make a teammate think their comment has been seen. A ticket you cannot open is a 404, the same 404 a ticket that never existed gives.
Inputs: task_uuid (required).
get_wiki_pageA
One wiki page in full, with its content and any attachments it references. Get page_uuid from get_wiki_tree or from a search_wiki hit — a page uuid is not a wiki uuid, and passing one for the other is a 404. A page you cannot open is that same 404, so it never confirms that a page exists. This server can create a page (create_wiki_page) and add to the end of one (append_wiki_page), but cannot change or delete what is already written: to correct something, append the correction rather than planning to edit the page.
Inputs: page_uuid (required).
get_wiki_page_versionA
What a wiki page said at an earlier version — its title, content and who saved it. This is how you recover something that was overwritten, and it is a READ: the page is not changed and its version does not move. Reach for it the moment you find that a page no longer says what you put there. version counts from 1 and goes up by one on every save; the current version is on the page from get_wiki_page. A version that was never saved, and a page you cannot open, are both the same 404. There is deliberately no tool here that puts an old version back — read it and append the wording you want, because a restore overwrites whatever a colleague has open in the live editor right now.
Inputs: version (required), page_uuid (required).
get_wiki_treeA
Every page in a wiki as a tree — titles, uuids and nesting — without any page content. This is the cheap way to find a page uuid when you know roughly where it sits; search_wiki is the way when you know roughly what it says. Follow up with get_wiki_page for the content of one. A wiki you cannot open is a 404, the same one a wiki that does not exist gives. A big wiki is tens of thousands of tokens of metadata, so narrow it with parent_page_uuid and depth rather than reading all of it to find one uuid.
Inputs: wiki_uuid (required), depth, parent_page_uuid.
link_ticketsA
Record that one ticket must be finished before another can start. Direction is from the point of view of task_uuid: "blocks" means task_uuid has to be done first. Every ticket read afterwards carries blocked_by, blocks and is_blocked, so this is how you work out what order to do things in.
Inputs: direction (required), task_uuid (required), other_task_uuid (required).
list_automationsA
The automation rules on a board — each with its trigger, conditions, actions, whether it is enabled, the user it runs as, and the version any edit would need. These are live: a rule with enabled: true fires on its trigger within a couple of seconds and applies its actions as the person named in run_as_user_uuid. Read this before creating a rule on a board you did not set up, both because the per-board limit counts what is already here (two on the free plan) and because an existing rule may already do what you were about to add. There is no tool for run history, though the API has one (GET /boards/:board_uuid/automations/:rule_uuid/runs), so a rule's outcomes have to be read there rather than here. A rule that switched itself off after looping shows up here as enabled: false. Board access is enough to read them, which is wider than creating one. A board you cannot open is a 404, the same 404 a board that never existed gives.
Inputs: board_uuid (required).
list_boardsA
The boards in a workspace, with their uuids and names — where you go from a workspace to something you can actually read. It lists only the boards this key can open, so a short list means limited access rather than an empty workspace, and archived boards are not in it. The uuid you want for get_board and list_tickets is here; the status uuids those need are not — get_board has those.
Inputs: workspace_uuid (required).
list_ticket_attachmentsA
The files on a ticket: name, content type, size in bytes and uuid, newest first. Nothing else here reads a ticket's files, so this is the way to find out whether the specification an agent is working from is actually a PDF somebody attached. get_ticket reports attachment_total, which is how you know whether calling this is worth a round trip. Only finished uploads are listed — an upload still in flight and a deleted file both read as absent — and the reply carries metadata, never the bytes; get_ticket_attachment fetches those one at a time.
Inputs: task_uuid (required).
list_ticketsA
Tickets on a board, in board order, optionally filtered by status or by free text. This is what to read a column or walk a whole board with; get_board returns the same tickets but takes neither limit nor a cursor. Paging: limit defaults to 50 and caps at 200, and next_cursor comes back only on a FULL page — a short page is the end of the walk, so stop when it is absent instead of calling again, and pass it back verbatim when it is there. Following a board over time: send the server_time from a previous reply as updated_since and you get only what changed since, plus removed_task_uuids for tickets that left the board or went out of view. Use the server's clock for that rather than your own, which is the whole point of server_time — your clock can drift and silently skip a ticket. Archived tickets are never returned.
Inputs: board_uuid (required), q, limit, cursor, +4 more.
list_wikisA
The wikis in a workspace, with their uuids — the only place a wiki_uuid comes from, so every other wiki tool starts here. workspace_uuid is required; start from list_workspaces if you do not have one. An empty list is not proof the workspace has no wiki: a key acting as a guest is excluded from workspace-wide reads and sees nothing here. Archiving a wiki (done in the browser; there is no tool here for it) takes it out of this list entirely, along with every page under it — pass archived: true to see those instead, which is also the only way to find a wiki_uuid for restore_wiki.
Inputs: workspace_uuid (required), archived.
list_workspacesA
The workspaces this key can act in, with their uuids, names and the role it holds in each. Start here when you do not already have a workspace uuid, then go to list_boards. Through an API key this is always exactly one workspace — the one the key was issued for — even when the person who created it belongs to several, so a single entry is the normal answer rather than a sign of missing access. Archived workspaces are not in it. Each entry carries billing_status, which is how you tell a workspace that has gone read-only from one you can still write to, before a write fails rather than after.
Inputs: no named parameters.
move_ticketA
Move a ticket to another column. Give either status (the column name) or status_uuid — with NEITHER this is a 400 ("body must NOT have fewer than 2 properties") and not a no-op, and with both it is a 400 saying to pick one. A column name is matched case-insensitively and trimmed, so "to do" finds "To Do", but a name no column has is a 400 naming it, and a status_uuid belonging to another board is refused too — get_board is where both come from. version must be the one get_ticket returned; a stale one is a 409 that carries the current version with it, so the retry does not need another read. The ticket is appended to the bottom of the column it arrives in unless you send a position; it does not keep the number it had in the column it left.
Inputs: version (required), task_uuid (required), status, position, +1 more.
restore_wikiA
Undo an archive: brings a wiki, and every page under it, back into list_wikis and back onto the internet if any of its pages were published. wiki_uuid comes from list_wikis with archived: true — that is the only place one is visible at all, since an archived wiki is invisible everywhere else this server reads. A wiki that is not archived, one in a workspace this key cannot open, and a uuid that does not exist are all the same 404, so this never confirms that a wiki exists. There is deliberately no tool here that archives one in the first place: that half stays a browser action.
Inputs: wiki_uuid (required).
searchA
Search tickets, wiki pages AND ticket comments across a whole workspace in one call, ranked by relevance with a highlighted excerpt. Use this when you know roughly what something is called but not which board or wiki it is on — list_tickets needs a board_uuid, this does not. The reply has FOUR lists: boards and tasks and pages matched their own text, and comments are tickets found by something said ABOUT them — each carries the ticket it belongs to, and a ticket already in tasks is never repeated there. boards is easy to miss and is often the one you want: it is how you find the board a term names without listing every board first. Matches whole words and prefixes, not mid-word substrings: 'deploy' finds 'deployment', 'eploy' finds nothing. Three characters minimum. Returns a short line per hit, not the full ticket or comment — follow up with get_ticket, get_ticket_comments or get_wiki_page. Each excerpt marks the matched words with the control characters \x01 and \x02 rather than with markup; strip them before showing the text to anyone.
Inputs: q (required), workspace_uuid (required), limit.
search_wikiA
Full-text search inside ONE wiki, returning matching pages with a highlighted excerpt. A title match outranks a body match, so the page actually about the term comes first. A single word also matches as a prefix — 'custom' finds 'Customark' — while a multi-word query keeps the usual search semantics: "quoted phrase", -excluded, and OR. Matches are marked in the excerpt with the control characters \x01 and \x02 around each hit, not with markup; strip them before showing the text to anyone. wiki_uuid comes from list_wikis, and a wiki that does not exist or that you cannot open is the same 404. To search tickets and wikis together across a whole workspace, use search instead.
Inputs: q (required), wiki_uuid (required).
unlink_ticketsA
Remove the link between two tickets. Order does not matter — it finds the pair from either end, so you do not have to know which one is recorded as the blocker. Note what it removes: Laver can hold more than one kind of link between the same pair (a dependency, a related-to, a duplicate-of), a person can add the other kinds in the web app, and this removes ALL of them rather than only the dependency link_tickets creates. It is not an error to unlink a pair that was never linked — nothing matches, nothing is removed, and the call still succeeds — so this cannot be used to test whether a link exists; read blocked_by and blocks on the ticket for that. Either uuid being unreadable, on a board you cannot open, or nonexistent is a 404.
Inputs: task_uuid (required), other_task_uuid (required).
update_ticketA
Change a ticket. version must be the one from get_ticket; a 409 means somebody wrote first and you should re-read. Markdown in description is parsed, and it replaces the whole description rather than appending to it. label_uuids, assignee_uuids and custom_fields each REPLACE the whole set rather than adding to it, so send what is already on the ticket alongside what you are adding or you will silently remove the rest. custom_fields is keyed by the field's uuid — read them off get_ticket, since a name will not do — and a uuid no field on that board has is DROPPED SILENTLY rather than refused: the call answers 200 and the value is simply not there. The task in the reply carries the stored custom_fields, so read them back to confirm a write landed rather than assuming a 200 means it did.
Inputs: version (required), task_uuid (required), title, status, +8 more.
upload_ticket_attachmentA
Attach a file to a ticket — the way an agent puts evidence on a ticket rather than describing it. Two ways to give it the bytes, and exactly one must be used. file_path reads a file from the machine THIS SERVER runs on (normally the agent's own machine, since the client starts this as a subprocess) and is the right one for anything that already exists on disk; it costs no context, so prefer it. text is for content the agent has just written — a log, a CSV, a diff — and needs filename alongside it. Laver refuses anything that is not one of application/pdf, application/vnd.openxmlformats-officedocument.presentationml.presentation, application/vnd.openxmlformats-officedocument.spreadsheetml.sheet, application/vnd.openxmlformats-officedocument.wordprocessingml.document, image/gif, image/jpeg, image/png, image/webp, text/csv, text/plain, and refuses a file whose BYTES do not match the type its name claims, so renaming a zip to .png fails at the server rather than here. 25 MB is the ceiling. A workspace over its storage quota is a 402, which no retry fixes. Uploading is a write: a read-only role is a 403.
Inputs: task_uuid (required), text, filename, file_path, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 30 tools
Each tool targets a distinct resource (ticket, board, wiki, automation, workspace) and a distinct action (list, create, get, update, move, etc.). Even similar tools like list_tickets and get_board are clearly separated by their descriptions. There is no ambiguity about which tool to call for a given operation.
Tool names follow a consistent verb_noun pattern throughout, e.g., list_tickets, create_ticket, update_ticket, get_wiki_page, restore_wiki. The only minor deviation is 'search' and 'comment_on_ticket', but the pattern remains predictable. No mixing of case or conventions.
With 30 tools, the surface is large, which could overwhelm agents. However, the server covers a broad domain (tickets, attachments, wiki, automations, boards) and each tool appears purposeful. It's on the heavy side but not extreme for the scope.
Ticket and attachment operations are fully covered, including archive/delete and comments. Wiki pages support create/append/versioning but intentionally not edit/delete. A notable gap is automation rules: they can be created and listed but not updated or deleted, which is a missing lifecycle.
Maintenance
Related MCP Connectors
Kanban boards, cards, checklists and team chat for AI agents. Hosted, OAuth sign-in, free.
Task & board management for AI agents + humans. Kanban, comments, digests via MCP.
Task and sprint coordination for humans and AI agents, with scoped API keys and full audit trail.
Kanban tasks and project notes for AI clients, with OAuth and per-project read or write grants.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceSelf-hosted kanban board that dispatches AI agent fleets against tickets. The embedded Streamable HTTP /mcp endpoint exposes 7 tools to list projects, read boards and tickets, and create, move and comment tickets from any MCP client.31AGPL 3.0
- AlicenseNot gradedqualityAmaintenanceEnables AI agents and humans to collaboratively manage kanban boards and Markdown documentation via MCP tools, with stable item keys, revision-safe editing, and full audit trails.AGPL 3.0
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to work a self-hosted kanban board as first-class users, exposing eleven kanban_* tools over a stateless Streamable HTTP endpoint for listing projects, stages, members and custom fields, and for creating, updating, moving and deleting tasks. Authenticates with bearer-token scopes so read-only or write access can be granted per agent, with every mutation audited.7MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents and humans to share one SQLite-backed kanban of tickets, exposing 10 tools to list workspaces, read, create, update and delete tickets, and manage comment threads. All tool output is plain text rather than JSON, so agents can read tickets cheaply, act on them, and reply with self-reported identity and model.MIT