Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}
prompts
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
kanbini_list_boardsA

Enumerate every board in the database with id, name, description, archived flag, list/card counts, and updatedAt (epoch ms; blends the board's own timestamp with the most recent activity-log entry for it, so the array sorts by real recency). Use this first to discover boardIds before calling kanbini_get_board. Returns [] if no boards exist. When the desktop app is closed, falls back to the last on-disk export and prefixes the response with a notice.

kanbini_get_boardA

Return one board: its labels, and every list with its cards. By default (detail: "summary") each card is one short line: number (the #N shown on the card, counted per board), title, and only what applies: completed, due (YYYY-MM-DD), priority, labels (names), checklist ("ticked/total"), description: true when it has one, comments / attachments counts, blocked (waiting on an open card), repeat. A list shows its first cardsPerList cards (default 50, in board order); a longer one says how many it left out in moreCards, and kanbini_get_list_cards filters or pages through them. Cards are named by number: pass #142 with this boardId to any tool that takes a card, and use kanbini_get_card for its description, checklists, comments and history. For one list, filtered (open / done, label, priority, due, text) or paged, use kanbini_get_list_cards. detail: "full" returns every card with all of its content, which is very large on a big board: avoid it. Archived cards are left out; archived lists show closed: true with no cards (kanbini_list_archived lists both). A list's visibleCardLimit / cardDensity and a card's collapsed are display settings only: every card is still returned. boardId is the id or exact name; omitted, the first board. Returns null if it matches nothing. When the desktop app is closed, falls back to the last on-disk export.

kanbini_get_list_cardsA

One list's cards, optionally filtered and paged. listId is the list's id or exact name, on boardId (id or name). Filters, all optional and combined: status "open" | "completed" | "all" (default); label (name or id) the card carries; priority (low/medium/high/urgent, or "none"); dueFrom / dueTo (YYYY-MM-DD, inclusive; a card without a due date never matches them); hasDue true/false; query (text in the title or description, any case). Returns { boardId, list: { id, name, cardCount }, matched (cards matching the filters), offset, cards, more (true when another page follows: call again with offset + cards.length) }. Cards come in the order the list shows them, as the same one-line summaries kanbini_get_board gives; detail: "full" returns them with all of their content (descriptions, checklists, comments, history). limit defaults to 50, max 200. Good for "what is still open in To Do", "every Bug card", or walking a long list page by page. When the desktop app is closed, falls back to the last on-disk export.

kanbini_get_cardA

Return one Kanbini card by id OR by its number - #142 or 142, the short #N the app shows on the card, which is how the user refers to cards. Numbers are counted per board, so a number needs its boardId (the id or name of the board the user means; without one this errors and lists the boards that have that number). Numbers handed out before they were per board are gone: look a card up again rather than trusting an old number. boardId is ignored for an id. Includes its id, number and boardId (keep the number and board together), title, description, priority (low/medium/high/urgent or null), checklists (with item ids), comments, attachments, recent activity feed, and its "waiting on" links: blockedBy (cards it waits on) and blocking (cards waiting on it), each with title, completed, archived, board, and list. A card is blocked while any blockedBy card is neither completed nor archived. Works for archived cards too (see kanbini_list_archived). Returns null if the id, or the number on that board, does not exist. When the desktop app is closed, falls back to the last on-disk export.

kanbini_search_cardsA

Global card search by case-insensitive substring on title, description, and label name; a query like #142 or 142 also finds each board's card with that number (numbers are per board; check boardName). Returns up to limit (default 50, max 100) hits, each carrying cardId + number + title + boardId + boardName + listName + matchedLabels + matchKind ("number" | "title" | "label" | "description") + updatedAt. Sort puts the numbered cards first, then title matches, then label, then description; ties break by recency. Archived cards and closed lists are excluded. Use cardId with kanbini_get_card to fetch full detail for any hit. When the desktop app is closed, falls back to the last on-disk export.

kanbini_get_agendaA

What's on the user's plate, across every board in one call. Returns four sections: overdue (open cards due before today), today (open cards due today), upcoming (open cards due in the next upcomingDays, default 7), and completed (cards marked complete today or in the previous completedDays, default 7, newest first). Due sections are ordered soonest first, then by priority. Each item carries cardId, title, boardId, boardName, listName, dueAt (epoch ms, local midnight of the due day), priority, completedAt, and blocked (still waiting on an open card, so it cannot really start yet). totals counts every card per section even when limit (default 50 per section, max 100) trims the arrays. "Today" is the local calendar day on the user's machine; dayStart is its midnight. Archived cards, archived lists, and archived boards are left out. Use this for "what should I work on", "what is overdue", or "what did I get done this week" instead of walking every board. When the desktop app is closed, falls back to the last on-disk export.

kanbini_create_boardA

Create a new empty board (no lists, no cards). name is the required board title; description is an optional short blurb shown on the home picker. Returns { id, boardId } - both equal the new board's id. Add columns next with kanbini_create_list, then cards with kanbini_create_card (or all of it in one kanbini_batch).

kanbini_create_listA

Create a new list (column) at the right end of a board. boardId is the board id or its exact name. Returns { id, boardId }; cards can then name the list by its id or name.

kanbini_create_cardA

Create a card, complete in ONE call: title plus any of description (Markdown, with real line breaks), due (YYYY-MM-DD) or dueAt (epoch ms at local midnight), priority ('low' | 'medium' | 'high' | 'urgent'), labels (names or ids of labels on that board; make a missing one with kanbini_create_label), checklists ([{ name, items: [text, ...] }]), repeat, and completed. It goes at the end of the list unless you give beforeId (the card that will sit directly ABOVE it) or afterId (the card directly BELOW). Returns { id, boardId }. Respect a list's wipLimit: it is advisory and not enforced, so check the card count before adding when one is set. A list can be given by its id, or by its exact name with boardId. Labels by name and cards by number need boardId too.

kanbini_update_cardA

Patch one or more card fields. title and description are strings; description accepts Markdown - use real line breaks for paragraphs and lists (a literal backslash-n renders as text, not a break). due is a YYYY-MM-DD day (or dueAt, epoch ms), null clears it. completed toggles the checkbox. coverAttachmentId is the attachment id to use as the cover banner, or null to clear. priority is one of 'low' | 'medium' | 'high' | 'urgent', or null to clear. collapsed only changes how the card is DRAWN in its list: true shows it compact, false keeps it full even in a compact list, null follows the list's cardDensity. It hides nothing from you, so change it only when the user asks for a tidier board. repeat makes the card repeat: { unit: 'day' | 'week' | 'month' | 'year', every: 1-99 } (e.g. { unit: 'week', every: 2 } for every two weeks), or null to stop. When a repeating card is completed, the app adds the next one to the list it was worked in, due one repeat after the old due date (always in the future), with the same title, description, labels, priority, and unticked checklists; the rule moves to the new card. Omit fields you do not want to change. Labels: kanbini_set_card_labels. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

kanbini_move_cardA

Move a card between lists, or reorder within its current list. toListId is the destination list. The position is optional and named from the moved card's point of view: beforeId is the card that will sit directly ABOVE it, afterId the card directly BELOW it. So to put card X right under card Y, pass beforeId: Y (not afterId). One neighbour is enough, the server works out the other. Omit both to add the card to the END of the list; pass only afterId = the first card to put it at the top. To place several cards in order, move the first one, then each next one with beforeId = the card you just moved (in one kanbini_batch). Respect the destination list's wipLimit when one is set (advisory, not enforced). Lists with a sortMode order themselves, so a move into one lands wherever the sort puts it. Card numbers are per board: a move to another board gives the card that board's next number, and its labels follow by name (the other board's label with the same name, or a new one there in the same colour). A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on). The list can be named too: on boardId, or on toBoardId for another board.

kanbini_copy_cardA

Make a copy of a card in any list, on this board or another one. The copy gets the title (or title), description, due date, priority, repeat rule, completion, labels (on another board: the label with the same name there, or a new one in the same colour), checklists with their ticks, and attachments. Comments, activity and "waiting on" links stay with the original. Position works like kanbini_move_card: beforeId is the card that will sit directly ABOVE the copy, afterId the one directly BELOW; omit both for the end of the list. So to put the copy right under the original, pass the original as beforeId. Returns { id, boardId } of the copy, which gets its own card number. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on). The list can be named too: on boardId, or on toBoardId for another board.

kanbini_delete_cardA

Permanently delete a card. Its checklists, comments, and attachment rows are removed by the FK cascade. Files attached to the card stay on disk until the GC sweep - they cannot be restored from the UI, so confirm intent before calling. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

kanbini_set_card_labelsA

Change a card's labels. labelIds are label ids or names (labels must belong to the card's board; make a missing one with kanbini_create_label). mode "replace" (the default) sets exactly these labels (an empty array removes all), "add" adds them to the ones it has, "remove" takes them off. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

kanbini_add_blockerA

Record that card cardId waits on card blockerId (a "blocked by" link). The card shows as blocked in the app until the blocker is completed or archived. The two cards may be on different boards. Adding a link that already exists does nothing. Rejected when both are the same card, or when blockerId already waits on cardId directly or through other cards (that would make a loop). A card's links are in the blockedBy and blocking arrays of kanbini_get_card. The user can undo in the app. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on). Two numbers must both be on that board; for a blocker on another board, use its id.

kanbini_remove_blockerA

Remove the link that makes card cardId wait on card blockerId. Removing a link that doesn't exist does nothing. Neither card changes otherwise. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

kanbini_post_commentA

Post a comment on a card. Author is automatically set to 'ai' so it renders with the AI badge in the UI (and is distinguishable from human-written comments). Body is Markdown - put real line breaks between paragraphs and list items. A literal backslash-n renders as the text "\n", not a line break. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

kanbini_update_commentA

Replace the text of a comment (ids are in the comments of kanbini_get_card). Markdown, with real line breaks. Comments the user wrote (author null) are theirs: change one only when they ask. The user can undo in the app.

kanbini_delete_commentA

Delete a comment from a card. Comments the user wrote (author null) are theirs: delete one only when they ask. The user can undo in the app.

kanbini_create_checklistA

Create a checklist on a card, with its items (texts, in order) in the same call. Returns { id, boardId }; add more later with kanbini_add_checklist_item. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

kanbini_rename_checklistA

Rename a card's checklist (ids are in the checklists of kanbini_get_card).

kanbini_delete_checklistA

Delete a whole checklist with all of its items. The user can undo in the app.

kanbini_add_checklist_itemC

Append an item to an existing checklist. Returns { id, boardId }.

kanbini_toggle_checklist_itemC

Set the completed flag on a checklist item. Pass true to mark it done, false to reopen.

kanbini_update_checklist_itemA

Change a checklist item's text, and/or tick it (completed). Omit what you do not want to change.

kanbini_move_checklist_itemA

Move a checklist item within its checklist or to another checklist (toChecklistId, which may be on another card). beforeId is the item that will sit directly ABOVE it, afterId the one directly BELOW; one is enough, and omitting both puts it at the end.

kanbini_delete_checklist_itemC

Remove one item from a checklist. The user can undo in the app.

kanbini_update_boardA

Patch a board. name renames it; description is the short blurb on the home picker (null clears it); color is the board accent shown on its home card and header tint (null clears it); pinned favourites it to the top of the home picker. Omit fields you do not want to change. id is the board id or its exact name. To archive a board use kanbini_archive_board. Colours: pass a palette name (red, orange, amber, yellow, lime, green, teal, cyan, sky, blue, indigo, purple, pink, rose) so it matches the app's swatch picker.

kanbini_update_listA

Patch a list (column). name renames it. color tints the list header and border (null clears it). wipLimit sets a work-in-progress cap - a positive integer, or null to remove it; the app shows the count against the cap and blocks drags past it, but the limit is NOT enforced for writes, so check the card count yourself before adding. sortMode orders the cards: "manual" (drag order, the default), "created-asc"/"created-desc" (card creation time), "added-asc"/"added-desc" (when the card entered this list), "due-asc" (soonest due first, undated last), "title-asc"/"title-desc" (alphabetical), "priority-desc" (urgent first). Switching back to "manual" freezes the current sorted order as the new drag order. onEnter runs when a card is moved INTO this list from another one: "complete" marks it done, "uncomplete" reopens it, null removes the rule. cardDensity "compact" draws every card in the list compact (a card can opt out with kanbini_update_card collapsed: false); "full" is the default. visibleCardLimit shows at most that many cards on screen, then a "Show N more" button (1-1000); 0 always shows every card; null (the default) lets the app shorten a list of more than 30 cards to its first 20 (the user can turn that off). Both are display only: the reads always return EVERY card, so never read a limit as the list being shorter. Change them only when the user asks. To reorder lists use kanbini_move_list; to hide one use kanbini_archive_list. A list can be given by its id, or by its exact name with boardId. Colours: pass a palette name (red, orange, amber, yellow, lime, green, teal, cyan, sky, blue, indigo, purple, pink, rose) so it matches the app's swatch picker.

kanbini_move_listA

Move a list (column) to a new position on its board. Named from the moved list's point of view: beforeId is the list that will sit directly to its LEFT, afterId the list directly to its RIGHT. So to put list X just right of list Y, pass beforeId: Y. One neighbour is enough, the server works out the other. Omit both for the far right; pass only afterId = the first list for the far left. Neighbours must be lists on the same board (closed lists count too, since they keep their slot). A list can be given by its id, or by its exact name with boardId.

kanbini_create_labelA

Create a new label on a board (boardId: id or name). Labels are board-scoped: put it on that board's cards by name or id. Check the board's labels first so you reuse an existing label instead of making a near-duplicate. Returns { id, boardId }. Colours: pass a palette name (red, orange, amber, yellow, lime, green, teal, cyan, sky, blue, indigo, purple, pink, rose) so it matches the app's swatch picker.

kanbini_update_labelA

Patch a label. name renames it and color recolours it - the change shows on every card carrying the label. Omit fields you do not want to change. Labels can be given by id or by name. (by name with boardId). Colours: pass a palette name (red, orange, amber, yellow, lime, green, teal, cyan, sky, blue, indigo, purple, pink, rose) so it matches the app's swatch picker.

kanbini_delete_labelA

Delete a label from its board. It is removed from EVERY card that carries it. The user can undo this in the app (Ctrl+Z), which puts it back on the same cards, but confirm intent first when the label is in use. Labels can be given by id or by name. (by name with boardId).

kanbini_archive_cardA

Archive (archived: true) or restore (archived: false) a card. An archived card disappears from the board, search, and card counts but keeps its list, position, checklists, comments, and attachments, so restoring puts it back exactly where it was. Tell the user the card was archived rather than deleted: they can see and restore it in the app from the board's pencil menu > Archived..., and kanbini_list_archived finds it too. Prefer this over kanbini_delete_card when the user wants a card "out of the way". A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

kanbini_archive_listA

Archive (archived: true) or restore (archived: false) a whole list (column). An archived list is hidden from the board along with every card in it, and its cards drop out of search and counts; nothing is deleted, and restoring brings the list back in its original slot with its cards. Tell the user: they can see and restore it in the app from the board's pencil menu > Archived..., and kanbini_list_archived finds it too. A list can be given by its id, or by its exact name with boardId.

kanbini_archive_boardA

Archive (archived: true) or restore (archived: false) a board. An archived board is hidden from the home picker (the user can still reach it with "Show archived") and its cards drop out of search. Nothing is deleted. kanbini_list_boards still returns archived boards, flagged archived: true. id is the board id or its exact name.

kanbini_delete_listA

Permanently delete a list (column) and every card in it. Prefer kanbini_archive_list unless the user asks for it to be deleted, and say how many cards go with it before you do. The user can undo it in the app (Ctrl+Z on that board). A list can be given by its id, or by its exact name with boardId.

kanbini_delete_boardA

Permanently delete a board with all of its lists, cards and labels. Prefer kanbini_archive_board unless the user clearly asks for it to be deleted; confirm the board by name first. The user can undo it in the app (Ctrl+Z from the boards home). id is the board id or its exact name.

kanbini_batchA

Apply many changes in ONE call, as one change: all of them land or none do, and one Ctrl+Z in the app takes them all back. Use it whenever you would otherwise call write tools several times (filling a board, tidying a list, moving or relabelling many cards). steps (up to 200) run in order; each is { op, ...arguments } where op is a write tool name without kanbini_ (create_card, update_card, move_card, set_card_labels, archive_card, create_list, create_label, post_comment, create_checklist, ...) and the arguments are exactly that tool's. boardId (id or name) is the default board for every step, so steps can name cards by number (#142) and lists / labels by name without repeating it; a step may still pass its own. A step that creates something can take ref: "name", and later steps use "$name" wherever an id goes, e.g. [{ op: "create_list", name: "Sprint 4", ref: "s4" }, { op: "create_card", listId: "$s4", title: "Plan" }]. Lists and labels a step creates can also be named by their name later on. Attachments are not available here. Returns { changes, steps: [{ step, op, id, ref? }] } with the id of what each step changed or made. A failing step is reported by number and nothing is changed.

kanbini_list_archivedA

Return what a board has archived: lists (archived lists, with how many live cards are inside) and cards (archived cards, most recently touched first, each with its list name). A card whose listClosed is true sits in an archived list, so restoring the card alone will not make it visible - restore the list too. Use the ids with kanbini_archive_card / kanbini_archive_list (archived: false) to bring things back. Returns null for an unknown boardId. When the desktop app is closed, falls back to the last on-disk export.

kanbini_add_attachmentA

Attach a file to a card, from ONE of two sources. (1) path: an absolute path to a local file, which the app copies in (up to 100 MB) - use this for files that already exist on disk. (2) filename + content: inline data you produce yourself, as encoding: "utf8" text (the default - notes, CSV, code) or encoding: "base64" for small binaries (up to 10 MB decoded). The filename's extension sets the file type; unsafe characters are replaced. Returns the stored attachment ({ id, filename, mime, size, ... , boardId }). To show an image as the card's cover, pass the returned id as coverAttachmentId to kanbini_update_card. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

kanbini_delete_attachmentA

Delete an attachment from its card, including the stored file. If it was the card's cover, the cover is cleared. The user can undo this in the app (Ctrl+Z) but the undo restores only the entry, NOT the file, so confirm intent first. Attachment ids come from kanbini_get_card.

Prompts

Interactive templates invoked by user choice

NameDescription
plan_my_dayReview what's overdue, due today, and coming up across all Kanbini boards, and suggest an order to work through it.
log_workRecord work that was just done as a completed Kanbini card, with a short write-up in its description.

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A3.9/5.0

Scored across 42 tools

Disambiguation4/5

Tools are cleanly partitioned by resource+action (board/list/card/label/checklist/comment/attachment/blocker), with clear read-vs-write and archive-vs-delete separation. The only real overlaps are toggle_checklist_item vs update_checklist_item (the former is a subset of the latter) and create_checklist vs add_checklist_item, both of which the descriptions do distinguish.

Naming Consistency5/5

Every tool follows the same kanbini_<verb>_<noun> snake_case pattern (create_card, update_board, archive_list, remove_blocker, set_card_labels). Verb choice is semantically consistent — get_ for single-resource reads, list_ for enumerations, move_/copy_/archive_ for specific mutations.

Tool Count3/5

42 tools is well above the comfortable band, but the domain genuinely spans nine entities (boards, lists, cards, checklists, checklist items, comments, labels, attachments, blockers) plus search, agenda, and batch. A few slots feel redundant (toggle_checklist_item, and the get_board/get_list_cards/get_card trio could be consolidated), so it is heavy rather than tight.

Completeness5/5

Full lifecycle is covered for boards, lists, cards, labels, checklists/items, comments, and attachments, plus blockers, archival, global search, an agenda view, and an atomic batch tool that composes the write surface. No obvious dead ends; the only minor omission is reading back attachment file content.

Maintenance

ActivityActive
ResponsivenessOutdated data