zentra-mcp
This MCP server exposes Zentra's Task board, Sprint, and Vault APIs as tools Claude can call directly.
Tasks: create tasks with title, project tag, type, status, priority, description, and optional parent/sprint; list tasks filtered by tag, type, status, or parent; move tasks to a new status and optionally into a sprint.
Sprints: list sprints, optionally filtered by status (e.g. OPEN), and use the returned sprint id to file tasks into that sprint.
Vault: create Vault pages with content, parent folder, and tag; list the Vault page tree or a page's children; upload a local file as an attachment to a page.
Authentication: supports interactive login (JWT stored locally) or
ZENTRA_TOKENfor unattended use, with API base URL overridable viaZENTRA_API_URL.
Click on "Deploy 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., "@zentra-mcpcreate a task to fix the login flow"
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.
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 |
| Create a task on the board, optionally filed straight into a sprint |
| List tasks, filtered by tag/status/type/parent |
| Move a task to a new status, optionally assigning it to a sprint |
| List sprints, optionally filtered by status (e.g. OPEN) |
| Create a Vault page, optionally with content, a parent folder (by id or name), and a tag |
| List the Vault page tree, optionally narrowed to one page's children |
| 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)
Install and build:
yarn install && yarn buildAuthenticate. 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 loginThis writes a JWT to
~/.config/zentra-mcp/credentials.json(mode600). The JWT expires after 7 days; re-run when a tool call reports "Session expired."Unattended — set
ZENTRA_TOKENto a long-lived service token, which takes precedence over the credentials file. This is how the scheduled daily runs authenticate; seedocs/service-token.mdin the Zentra repo for how to mint one.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.shinstalls dependencies whennode_modulesis missing and builds whendist/is missing or stale (anysrc/*.tsnewer thandist/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 everygit pull, since an out-of-datedist/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
tagname 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:
Start a Claude Code session in each project you use this from.
In each, ask Claude to create a task via
zentra_task_create(it should infer thetagfrom the project you're in).Confirm each task appears correctly — right title, tag, status — on the Zentra web UI's task board.
Ask Claude to list and move a task via
zentra_task_list/zentra_task_moveand confirm the board reflects it.Ask Claude to create a Vault page via
zentra_vault_create_page, then attach a local file to it viazentra_vault_upload_attachment. Confirm the page and its attachment appear in the Vault on the web UI. Note thatfilePathis read on the machine running this server, not on Claude's side.Ask Claude to create a Vault page with
folderset to the name of an existing folder andtagset to a registered tag. Confirm the page lands under that folder, tagged, on the web UI.Ask Claude to list sprints via
zentra_sprint_listwithstatus: "OPEN", then create or move a task with that sprint's id assprintId. Confirm the task shows up in that sprint on the web UI.
Available Tools
3 toolszentra_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.
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | Project 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. | |
| type | No | Defaults to TASK. | |
| title | Yes | ||
| status | No | Initial status. Defaults to TODO. | |
| parentId | No | Parent task id: an EPIC for a BUG/TASK, or a TASK for a SUBTASK. | |
| priority | No | Defaults to MEDIUM. | |
| description | No |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | ||
| type | No | ||
| status | No | ||
| parentId | No | Filter to tasks whose parent is this task id. |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ||
| status | Yes |
TDQS
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.
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.
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.
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.
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.
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.
3 tool updates
v0.1.0- First observed
zentra_task_create - First observed
zentra_task_list - First observed
zentra_task_move
TDQS
Scored across 3 tools
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.
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.
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.
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
Related MCP Connectors
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
- mcpOAuthnet.todoist
Official Todoist MCP server for AI assistants to manage tasks, projects, and workflows.
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
Related MCP Servers
- AlicenseBqualityDmaintenanceAn MCP server that connects Claude with Todoist for complete task and project management through natural language.86199 npm247MIT
- FlicenseNot gradedqualityDmaintenanceAn OAuth-authenticated MCP server that bridges Claude AI with a task management system, allowing users to list, create, and update tasks through natural language commands.1-
- AlicenseAqualityDmaintenanceMCP server that exposes NirvanaHQ (GTD task manager) to Claude Code, enabling task management and project tracking through natural language.1517 npmMIT
- AlicenseNot gradedqualityDmaintenanceMCP server for managing Kaiten tasks through AI agents like Claude, enabling task retrieval, creation, updating, and time logging.27 npm2MIT