Skip to main content
Glama

zentra-mcp

MCP server exposing Zentra's Task and Vault APIs as tools Claude can call directly, from any project, not just from inside the Zentra repo:

Tool

What it does

zentra_task_create

Create a task on the board, optionally filed straight into a sprint

zentra_task_list

List tasks, filtered by tag/status/type/parent

zentra_task_move

Move a task to a new status, optionally assigning it to a sprint

zentra_sprint_list

List sprints, optionally filtered by status (e.g. OPEN)

zentra_vault_create_page

Create a Vault page, optionally with content, a parent folder (by id or name), and a tag

zentra_vault_list_pages

List the Vault page tree, optionally narrowed to one page's children

zentra_vault_upload_attachment

Upload a local file as an attachment on a Vault page

zentra_sprint_list resolves sprints (e.g. the OPEN one) by id, and that id can then be passed as sprintId to zentra_task_create or zentra_task_move to put a task in a sprint.

Extracted from the Zentra monorepo (packages/mcp) so that Zentra's sibling projects can use it without checking out Zentra. It builds standalone: the few task-board and Vault types it needs are vendored in src/board-types.ts rather than imported from @zentra/shared.

Setup (one time)

  1. Install and build:

    yarn install && yarn build
  2. Authenticate. Two ways:

    Interactive — run in a real terminal, not through Claude, since this is the only place your password is typed:

    node dist/cli.js login

    This writes a JWT to ~/.config/zentra-mcp/credentials.json (mode 600). The JWT expires after 7 days; re-run when a tool call reports "Session expired."

    Unattended — set ZENTRA_TOKEN to a long-lived service token, which takes precedence over the credentials file. This is how the scheduled daily runs authenticate; see docs/service-token.md in the Zentra repo for how to mint one.

  3. Register the server with Claude Code at user scope, so it's available in every project:

    claude mcp add zentra-mcp --scope user -- sh "$(pwd)/bin/zentra-mcp.sh"

    bin/zentra-mcp.sh installs dependencies when node_modules is missing and builds when dist/ is missing or stale (any src/*.ts newer than dist/cli.js), then execs the server. The missing case matters for fresh checkouts, where MCP stdio servers are spawned before anything has had a chance to build; the stale case matters after every git pull, since an out-of-date dist/ otherwise gets served silently and new tools never show up. Build output goes to stderr so stdout stays a clean protocol channel.

    Claude Code reads a server's tool list once, when it spawns the server at session start. Restart the session after changing tools — a running session will not pick them up.

Related MCP server: Procrastinator MCP Server

Configuration

  • ZENTRA_TOKEN — bearer token to authenticate with, preferred over ~/.config/zentra-mcp/credentials.json. Used by unattended automation.

  • ZENTRA_API_URL — override the API base URL (defaults to the production Render deployment). Useful for developing against a local API.

Project tags

Every task carries a tag naming its project, and a Vault page created via zentra_vault_create_page can optionally carry one too.

Zentra's API is migrating tags from free text (tags: string[]) to a registry (GET /api/tags, tagIds: string[]), but this server ships on its own schedule, not in lockstep with that API — so it detects which one it's talking to (by probing GET /api/tags once per session) and works either way, with no configuration needed:

  • Registry available: a tag name is resolved to its registered id case-insensitively. Creating a task, or tagging a page, with a name that isn't registered fails with a clear error; listing tasks by an unregistered tag is treated as a legitimate "nothing matches" query and returns an empty list instead. Register a project's tag in Zentra before using it here.

  • Registry not (yet) deployed: tags are matched by exact string, after trimming whitespace — any free text is accepted, there is no enforced set, and asking for the wrong one returns an empty list rather than an error, same as this server behaved before the registry existed.

This is transparent to callers either way — the same tag input works in both worlds. See the comment above resolveTagForWrite/resolveTagForFilter in src/tag.ts for the mechanics, and for the condition under which the legacy path can eventually be deleted.

Manual verification

There's no automated integration test against the live production API — that would require storing real credentials in CI. After setup, verify by hand:

  1. Start a Claude Code session in each project you use this from.

  2. In each, ask Claude to create a task via zentra_task_create (it should infer the tag from the project you're in).

  3. Confirm each task appears correctly — right title, tag, status — on the Zentra web UI's task board.

  4. Ask Claude to list and move a task via zentra_task_list/zentra_task_move and confirm the board reflects it.

  5. Ask Claude to create a Vault page via zentra_vault_create_page, then attach a local file to it via zentra_vault_upload_attachment. Confirm the page and its attachment appear in the Vault on the web UI. Note that filePath is read on the machine running this server, not on Claude's side.

  6. Ask Claude to create a Vault page with folder set to the name of an existing folder and tag set to a registered tag. Confirm the page lands under that folder, tagged, on the web UI.

  7. Ask Claude to list sprints via zentra_sprint_list with status: "OPEN", then create or move a task with that sprint's id as sprintId. Confirm the task shows up in that sprint on the web UI.

Available Tools

3 tools
zentra_task_createCreate a Zentra taskA

Creates a task on Zentra's production task board. tag identifies the project this task belongs to — infer it from your own working directory and always pass it explicitly; any text works, not just a fixed set of known projects. type defaults to TASK; use parentId to link a BUG/TASK to an EPIC or a SUBTASK to a TASK.

ParametersJSON Schema
NameRequiredDescriptionDefault
tagNoProject this task belongs to, e.g. the repository or product name — any text is accepted. Required in practice — omitting it fails the call with a clear error — but declared optional at the schema level so that failure comes from `requireTag` with the exact documented message, not a generic schema-validation error.
typeNoDefaults to TASK.
titleYes
statusNoInitial status. Defaults to TODO.
parentIdNoParent task id: an EPIC for a BUG/TASK, or a TASK for a SUBTASK.
priorityNoDefaults to MEDIUM.
descriptionNo

TDQS

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses that this writes to a production board, that tag is required in practice despite being schema-optional, and that any text is accepted for tag. No contradictions with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three tightly focused sentences: purpose, tag guidance, and type/parent behavior. Every sentence adds value and there is no redundancy or fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description covers the essential context for a create tool: production target, key parameter behaviors, and type/parent relationships. Minor gaps like return values are acceptable when no output schema exists and the schema fills in most field details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is high (71%), but the description adds meaningful nuance: inferring tag from the working directory, always passing it explicitly, and the parentId hierarchy (BUG/TASK to EPIC, SUBTASK to TASK). This goes beyond the schema's field descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with 'Creates a task on Zentra's production task board' — a specific verb and resource with clear scope. Sibling tools (list, move) are obviously different operations, so the tool is well differentiated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives explicit instructions for the tag parameter ('infer it from your own working directory and always pass it explicitly') and explains type defaults and parentId linking rules. It doesn't name alternatives but the use case is clear from the create vs list/move context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

zentra_task_listList Zentra tasksA

Lists tasks from Zentra's production task board, optionally filtered by project tag and/or status. Omit tag to see tasks across all projects.

ParametersJSON Schema
NameRequiredDescriptionDefault
tagNo
typeNo
statusNo
parentIdNoFilter to tasks whose parent is this task id.

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only adds one behavioral note about omitting 'tag', but does not disclose the return format, pagination, read-only nature, potential errors, or any side effects. This is a significant transparency gap for a tool with no annotation support.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences long, front-loaded with the primary action, and contains no redundant or filler wording. Every sentence contributes useful information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With four optional parameters and no output schema or annotations, the description is incomplete. It only mentions two of the four filter parameters (tag and status) and does not describe the output format or behavior beyond the filter logic. This leaves significant context gaps for an agent selecting and invoking the tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 25%, so the description must compensate. It clarifies that 'tag' refers to a project tag and that omitting it returns all projects, and it mentions 'status' as a filter. However, it does not explain 'type' or 'parentId', leaving those parameters without additional semantic context beyond their raw schema definitions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Lists tasks from Zentra's production task board' with a specific verb and resource, and mentions optional filters by tag and status. This distinguishes it from sibling tools 'zentra_task_create' and 'zentra_task_move', which are write operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides clear context: lists tasks from the production board, and explicitly advises omitting 'tag' to see tasks across all projects. It does not explicitly state when not to use it, but the read-only nature of listing is clear from the sibling tool names, making the context sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

zentra_task_moveMove a Zentra task to a new statusB

Updates an existing task's status by id.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
statusYes

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only states that it updates status, without mentioning whether the operation is idempotent, whether status transitions are validated, what happens on invalid transitions, or what is returned. This is insufficient for a mutating tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no filler. Every word contributes to purpose and parameter identification.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool is a mutation with no output schema and no annotations, the description is incomplete. It does not explain what the response looks like, possible error conditions, or whether status transitions are restricted. This leaves significant ambiguity for an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It mentions 'status' and 'by id', identifying the roles of both parameters. However, it adds no extra meaning beyond the schema's own names and enum, such as transition rules or format expectations.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Updates an existing task's status by id' clearly specifies the action (updates), the resource (task), the attribute (status), and the identifier (id). This distinguishes it from sibling tools zentra_task_create (new task) and zentra_task_list (read tasks).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage context is implied: the verb 'updates' and 'existing task' indicate this is for modifying an already created task, not for creating or listing. However, no explicit alternatives or exclusionary guidance is given, unlike a tool that names a sibling alternative.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 3 tool updatesv0.1.0
    • First observedzentra_task_create
    • First observedzentra_task_list
    • First observedzentra_task_move

TDQS

A3.9/5.0

Scored across 3 tools

Disambiguation5/5

The three tools have clearly distinct purposes: create, list, and move (status update). There is no overlap in functionality, making it easy for an agent to select the right operation.

Naming Consistency5/5

All tool names follow the identical pattern `zentra_task_<verb>` with snake_case. This consistent verb_noun structure makes the API predictable and easy to navigate.

Tool Count4/5

At 3 tools, the server is concise but not under-powered for a focused task management use case. The count is within the well-scoped range, though slightly lean.

Completeness4/5

The set covers the core lifecycle: creation, listing/filtering, and status transitions. Missing operations like full detail retrieval or deletion are minor gaps that can often be worked around via listing, but a dedicated get/update would improve completeness.

Maintenance

ActivitySlowing
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers