Allows interaction with GitHub Projects v2 kanban boards, providing tools to list boards, retrieve board details, and generate board summaries.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@kanban.board Summarize the current state of my kanban board."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A GitHub Projects v2 kanban board for Precursor — and the reference implementation of a Precursor plugin.
One package, three contributions:
A section — sidebar entry, home card, command-palette entry and a
/kanban route, with columns derived from each project's Status
single-select field, drag-and-drop card moves
(updateProjectV2ItemFieldValue), and a card preview showing the issue body,
labels and comments plus a jump to the linked Precursor topic. The UI is a
built ES module shipped inside this wheel, loaded by the app at runtime.
MCP tools — a kanban.board server (list_boards, get_board,
board_summary) so the assistant can read your boards mid-conversation.
API routes — /api/github/projects, backing the board.
Remove the package and all three disappear; core keeps no knowledge of them.
Related MCP server: GitHub Projects MCP Server
uv pip install precursor-kanban # into an existing Precursor install
uv tool install "precursor-ai[kanban]" # or alongside the app…or from Settings → Plugins inside the app, which also offers the restart.
Precursor discovers it at startup through the precursor.plugins entry-point
group; no configuration is needed.
The plugin targets two versioned contracts — precursor.plugin_api on the
Python side and @precursor/host on the frontend side. They move independently
of each other and of the host's own version.
precursor-kanban | Python contract | Frontend contract |
|
|
|
Requires a Precursor newer than
2026.7.0.precursor.plugin_api— the entire surface this package compiles against — landed on Precursor'smainafter that release, so2026.7.0cannot load this plugin at all. Use a host built frommain, or the next release.
Issue associations enabled in Settings → GitHub — the master switch for the whole GitHub surface; the board's endpoints answer 403 without it.
A GitHub repository is optional. When set it contributes its owner's boards, which is all it is ever read for; otherwise add projects from the board's +.
A token carrying the project scope (a superset of read:project), which the
repo scope does not imply:
gh auth refresh -h github.com -s projectWithout it the board returns a 403 explaining exactly this.
Path | Role |
|
|
|
|
| ProjectsV2 GraphQL queries (extends core's |
| Board read models |
| The |
| Frontend source — |
| The bundle's own Tailwind utilities (see below) |
| Our declaration of the host SDK we compile against |
| Built frontend, shipped in the wheel (gitignored) |
| Provisions and runs a host to load this plugin into |
| GitHub Copilot app project settings (setup + dev server) |
See Precursor's plugin documentation for the full contract.
make sync # uv sync + npm ci + build the frontend bundle
make check # every gate CI runs
make test # the test suite alone
make build # rebuild the frontend into the Python packageA plugin has nothing to run on its own. The section, the routes and the MCP
server only exist inside a host that discovered them through the
precursor.plugins entry point, so seeing the board means running a Precursor
with this working tree installed into it:
make dev-host # provision a host beside this checkout, plugin installed into it
make dev # run its dev stack — Vite HMR + uvicorn --reloadscripts/dev-host.sh clones the host's main into .precursor-host/
(gitignored, disposable), syncs its environment, and installs this repository
into it editable — so Python changes need only a restart and frontend
changes only make build. make dev runs with --port 0, meaning the OS picks
a free port and several checkouts can serve their own board at once; the URL is
in the startup banner. Override the host with PRECURSOR_HOST_REPO,
PRECURSOR_HOST_REF, PRECURSOR_HOST_DIR or PRECURSOR_HOST_EXTRAS.
The host from uv sync is deliberately not what this runs. That one is
resolved from git as a wheel built without its npm step, so it has the backend
and no SPA — enough for the test suite to boot an app, nothing to look at.
On a device that routes packages through a mirror, uv sync --frozen cannot
work here: it downloads the files.pythonhosted.org URLs recorded in uv.lock,
which such devices block, and --index cannot redirect a URL the lockfile
already pinned. The script falls back to uv export + uv pip install, which
keeps the locked versions and their hashes but lets the configured index serve
them; npm ci falls back to npm install --no-package-lock for the same reason.
Neither lockfile is ever written — CI owns both. If the mirror is behind on a
pinned version the plugin's own environment may still fail; the host is set up
first, so make dev works regardless and only make test has to wait.
In the GitHub Copilot app both steps are already wired up in
.github/github-app.yml: Setup env runs on session
create, and Dev Server is one click away. Accept the configuration when the
app offers it.
Four things are worth knowing before changing anything.
The frontend is a build product. src/precursor_kanban/web/ is generated and
gitignored. Without it the backend still advertises the section, the app has
nothing to import, and the section silently doesn't appear — so make sync and
make check both build it for you.
The bundle borrows the host's React. react, react-dom, both JSX runtimes
and @precursor/host are marked external; an import map injected by Precursor
resolves them to its own runtime. That is what keeps a single React on the page.
Bundling our own would give the app two dispatchers and every hook here would
throw — so CI asserts the built bundle still imports them rather than containing
them.
The bundle ships its own Tailwind utilities. Inside the Precursor monorepo
this was free: the host's Tailwind build scanned these sources and its stylesheet
already carried every class they used. Out of tree it cannot — the sources ship
compiled — so web/src/styles.css builds the utilities this plugin needs and
styles.ts injects them. They resolve against the host's theme variables, so the
board stays themed with the app and follows dark mode with it.
Lockfiles are generated by CI, never locally — a corporate mirror rewrites
artifact URLs and downgrades their hashes. Run make hooks once to have that
blocked at commit time.
More detail, including how the test suite pins the host and how to keep the SDK declaration honest, is in CONTRIBUTING.md.
MIT, same as Precursor.
Summarise a board as counts per column, plus its total card count.
Cheaper for the model to reason over than the full card list when the question is "where does the work stand?".
| Name | Required | Description | Default |
|---|---|---|---|
| project_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior itself. It states the output shape (counts per column and total) and the cost advantage of the summarised result, which conveys a read-only style operation. It does not explicitly declare that it makes no modifications, but for a summarisation method that is safely implied, and no contradictions exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two crisp sentences; the action and output are front-loaded, and the cost/purpose rationale is a separate line. Every word earns its place, no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple summary operation with one required parameter and an output schema likely describing the counts, the description conveys the shape of the result and the intended use case. It lacks explicit guidance on how to obtain the project_id, but the tool's simplicity and the presence of list_boards among siblings make that omission minor. Overall it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has one parameter, project_id, with 0% description coverage, and the tool description does not mention it or offer any constraints or format. Since schema coverage is low, the description was expected to compensate, but it does not; however, the parameter name 'project_id' is reasonably self-explanatory.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb 'Summarise' and resource 'board', precisely noting the output is 'counts per column, plus its total card count'. The 'Cheaper than the full card list' phrase differentiates it from sibling get_board, clearly marking it as an aggregation tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Tells when to reach for it: when the question is 'where does the work stand?', because it is cheaper than the full card list. It does not explicitly name sibling tools nor state a when-not, but the rationale leaves no room for ambiguity that full-detail retrieval would be needed for anything beyond a summary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read one board: its Status columns and every issue/PR card on it.
``project_id`` is the opaque node id from ``list_boards`` (e.g. ``PVT_…``).
Each card carries its ``number``, ``title``, ``state``, ``repo``, ``labels``
and the ``status_name`` column it sits in.
| Name | Required | Description | Default |
|---|---|---|---|
| project_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are not provided, so the description carries the full burden of behavioral disclosure. It describes the read operation and what data will be returned, which implies a safe, non-destructive action, but it does not mention potential errors, authentication requirements, or any other side effects or behaviors beyond the read.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably sized and front-loaded: it immediately states the purpose, then provides essential parameter context, and lists the data returned. However, it includes some degree of detail that might be redundant given the output schema, but it still adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is an output schema, so the description does not need to explain return values in depth, but it does anyway. With only one parameter and a clear description of what the tool returns, the description adequately covers what an agent needs to call the tool correctly, though it could capably mention error cases or prerequisites.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by explaining that project_id is an opaque node ID from list_boards and providing an example format (e.g., PVT_...). This adds meaningful meaning and helps the agent know what value to supply.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads one board and its contents, using a specific verb ('Read') and resource ('one board'). It distinguishes itself from list_boards by referencing how to obtain the project_id, but does not explicitly differentiate from board_summary. The phrasing 'opaque node id from list_boards' clarifies its relationship to a sibling tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear context for usage by explaining that project_id comes from list_boards and giving an example format, but it does not explain when to use this tool versus board_summary or any exclusions. There is no explicit guidance on when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the GitHub Projects v2 boards the user tracks.
Covers the configured repository's account when there is one, plus every
project source added on the board. Returns each board's ``id`` (needed by
``get_board``), ``number``, ``title`` and ``url``.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of explaining behavior. It discloses the source scope, that only tracked boards are returned, and the exact fields returned. It does not discuss pagination or ordering, but for a zero-parameter listing tool this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences with the main purpose first, followed by scope and return-value details. Every sentence adds useful information and there is no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-parameter listing tool with an output schema, the description covers what the tool does, what it includes, and what it returns. It even notes the id's role with get_board, so an agent has enough context to invoke and use the result correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, so there is nothing for the description to add beyond what the schema already makes obvious. The baseline for zero-parameter tools is 4, and the description appropriately focuses on outputs rather than invented parameter detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource ('List the GitHub Projects v2 boards the user tracks') and clarifies scope ('configured repository's account', 'every project source added on the board'). It also names the return fields and links the id to get_board, which distinguishes it from its siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly indicates when to use the tool: to list tracked boards and obtain their ids for later use with get_board. It does not explicitly name sibling alternatives or exclusion cases, but the intended use is clear from the context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a distinct role: discovering boards, reading a full board, and producing a column summary. Descriptions clarify when to use board_summary vs get_board, so there is no ambiguity.
list_boards and get_board follow a clear verb_noun pattern, but board_summary uses a noun phrase instead. The names remain readable and consistent in domain terminology, but this small deviation makes the set mostly consistent rather than fully uniform.
With three tools, the server is tightly scoped to reading and summarizing Kanban boards. Each tool has a clear purpose, and the count feels appropriate rather than excessive or thin.
The tools cover board discovery, full board retrieval, and aggregate summaries, which is complete for a read-only Kanban workflow. The absence of write operations (create/update/move) is a notable gap if broader board management is expected, but for the stated tracking purpose the surface is sufficient.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Read and manage your EasyKanban kanban boards: to-do summaries, create, update, and move cards.
Remote MCP for Kanban AI boards—manage projects, tasks, and comments from AI tools.
Read and manage your Pantts boards — kanban, gantt, table and graph over one shared card model.
Create, read and live-edit visual boards, Kanban plans, Gantt timelines and diagrams with AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/lrivallain/precursor-kanban'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
