What can you do with this server?

This server connects an MCP client to a Taiga instance, letting you inspect and manage projects, work items, sprints, comments, attachments, and wiki pages through six consolidated tools. * projects: list accessible projects, get project metadata, and verify credentials with whoami. * work: list, get, create (including batch up to 20), update, link/unlink, and delete issues, user stories, tasks, and epics. * sprints: list, inspect, create, and get progress statistics for sprints/milestones. * comments: list, add, edit, and soft-delete comments on work items and wiki pages. * attachments: list, upload (from file path or base64), download, and delete attachments. * wiki: list, get, create, update, delete, and watch/unwatch wiki pages. * Uses human-friendly identifiers (project slugs, #references, names, usernames, "me") and resolves statuses/priorities/severities/issue types/sprint names server-side.

How do I use Taiga MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Taiga MCP Server List the open user stories in the Acme Web project." 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.

en es ja ru

Taiga MCP Server

by negoro26

Overview Schema Related Servers Score Discussions

TypeScript

Local

Taiga MCP Server

npm version Node.js License MCP

Model Context Protocol (MCP) server for Taiga project management, written in TypeScript and built on the Model Context Protocol SDK over stdio transport (with an optional streamable HTTP transport for remote and web-based clients). It connects LLM clients to Taiga instances to inspect and manage projects, work items (issues, user stories, tasks, epics), sprints, comments, attachments, and wiki pages.

The server consolidates all capabilities into 6 op-dispatching tools designed for minimal token overhead and dense, human- and LLM-readable text responses.

Features · Requirements · Quick Start · Local checkout · HTTP transport & web clients · Docker
Install: Claude Code · Claude Desktop · VS Code / Copilot · Cursor · Windsurf · Cline / Roo / Kilo · Continue.dev · Zed · JetBrains · Gemini CLI · Codex CLI · opencode · Amp · Pi · Oh My Pi
Tools: Conventions · Why six tools · Tool reference: projects · work · sprints · comments · attachments · wiki
Operations: Reliability · Security · FAQ · Troubleshooting · Development · Contributing · Changelog · License

Related MCP server: @illodev/taiga-mcp

Features

Six tools, twenty-eight operation pairs across projects, work items, sprints, comments, attachments, and wiki pages — the entire tools/list payload is ~10,493 characters (~2,800 tokens).
Human-friendly identifiers everywhere: projects by ID or slug, work items by database ID or #reference, members by ID, username, full name, or "me"; statuses, priorities, severities, issue types, and sprint names resolve server-side.
Dense text output: one line per record in listings, clean key-value detail views; empty collections are reported as data, not errors.
Batch creation of up to 20 work items in a single call; deletions are deliberately single-target.
Reliability rails: rate-limit retries honoring Retry-After, 30-second HTTP timeouts, a 60-second metadata cache, and no automatic 5xx retries (mutating requests may have landed).
Attachment safety: hostname-pinned downloads, 10 MB cap, overwrite protection, and no bearer token sent to media hosts.
Dual transport: stdio by default; streamable HTTP on loopback when TAIGA_HTTP_PORT is set.

Requirements and Configuration

Node.js >= 20.11
A Taiga account on taiga.io or a self-hosted Taiga instance
Three environment variables configured:

Variable	Description	Default
`TAIGA_API_URL`	Base URL of the Taiga REST API (must include `/api/v1`)	`https://api.taiga.io/api/v1`
`TAIGA_USERNAME`	Taiga username or email	Required
`TAIGA_PASSWORD`	Taiga account password	Required

Optional transport variables:

Variable	Description	Default
`TAIGA_HTTP_PORT`	When set, serve MCP over streamable HTTP instead of stdio	(unset: stdio)
`TAIGA_HTTP_HOST`	Bind host for the HTTP transport	`127.0.0.1`

Quick Start

The fastest setup is Claude Desktop with npx (no checkout required):

{
  "mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

All harness configurations below follow this shape; only the file location and wrapper syntax differ.

Credentials and .env: a local checkout automatically loads .env from the repository root (see .env.example). An npx install does not: dotenv resolves relative to the package's install location inside the npm cache, so credentials passed via npx MUST be set in each harness's env block as shown above.

Running From a Local Checkout

git clone https://github.com/negoro26/mcp-taiga.git
cd mcp-taiga && npm ci && npm run build
cp .env.example .env   # fill in TAIGA_USERNAME / TAIGA_PASSWORD

Then point any harness at the compiled entrypoint instead of npx:

{
  "mcpServers": {
    "taiga": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-taiga/dist/src/index.js"]
    }
  }
}

No env block needed here — the server loads your repo-root .env itself. This repository also ships a ready-made .mcp.json so coding agents opened inside the checkout can use the local build directly.

Installation and Configuration

Per-harness setup using the published npm package. Each snippet passes credentials inline; substitute your own values.

Claude Code

Project scope (checked into the repo, shared with your team):

// .mcp.json at repository root
{
  "mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

Or add from the CLI (user scope with -s user, local scope by default):

claude mcp add taiga \
  -e TAIGA_USERNAME=your_username \
  -e TAIGA_PASSWORD=your_password \
  -- npx -y mcp-taiga

Verify with claude mcp list or /mcp inside a session.

Claude Desktop

Edit the config file — claude_desktop_config.json via Claude Desktop → Settings → Developer → Edit Config, located at %APPDATA%\Claude\claude_desktop_config.json on Windows or ~/Library/Application Support/Claude/claude_desktop_config.json on macOS — and restart the desktop app:

{
  "mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

On Windows, invoke npx through cmd /c if the direct form fails: "command": "cmd", "args": ["/c", "npx", "-y", "mcp-taiga"].

VS Code and GitHub Copilot

VS Code supports MCP servers natively (1.99+); Copilot Chat picks them up automatically.

// .vscode/mcp.json (workspace) or use Command Palette: "MCP: Add Server"
{
  "servers": {
    "taiga": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

Start it from the Extensions view (mcp.json shows a Start button) or run MCP: List Servers in the Command Palette. Inputs can reference secrets with the "inputs" field instead of hardcoding passwords.

Cursor

Via CLI (mirrors the Claude Code interface):

cursor mcp add taiga -e TAIGA_USERNAME=your_username -e TAIGA_PASSWORD=your_password -- npx -y mcp-taiga

Or edit ~/.cursor/mcp.json (global):

{
  "mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

Enable the server under Cursor Settings → MCP & Integrations if it does not activate immediately.

Windsurf

Edit ~/.codeium/windsurf/mcp_config.json (or Windsurf Settings → Cascade → MCP Servers → Manage MCPs → View Raw Config) and refresh the MCP panel afterwards:

{
  "mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

Cline, Roo Code, and Kilo Code

All three VS Code extensions read an equivalent JSON settings file, editable through each extension's MCP Servers panel (the pencil icon opens the raw file):

Extension	Settings file (Linux paths; macOS uses `~/Library/Application Support/Code/User/...`, Windows `%APPDATA%\Code\User\...`)
Cline	`~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
Roo Code	`~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json`
Kilo Code	`~/.config/Code/User/globalStorage/kilocode.kilo-code/settings/mcp_settings.json`

Add the server inside the top-level "mcpServers" object:

{
  "mcpServers": {
    "taiga": {
      "disabled": false,
      "timeout": 60,
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

Approve the server's tool use when the extension prompts; per-tool auto-approval can be configured in the same panel.

Continue.dev

Continue reads MCP servers either from mcpServers: blocks in its config or from standalone YAML files in .continue/mcpServers/ (it also accepts Claude/Cursor/Cline JSON configs dropped into that directory unchanged):

# ~/.continue/config.yaml (or .continue/mcpServers/taiga.yaml with
# name/version/schema metadata fields added)
name: Assistant
version: 1.0.0
schema: v1
mcpServers:
  - name: Taiga
    type: stdio
    command: npx
    args:
      - -y
      - mcp-taiga
    env:
      TAIGA_USERNAME: your_username
      TAIGA_PASSWORD: your_password

MCP tools are available in agent mode.

Zed

Add a custom context server in settings.json (zed: open settings):

{
  "context_servers": {
    "taiga": {
      "command": {
        "path": "npx",
        "args": ["-y", "mcp-taiga"],
        "env": {
          "TAIGA_USERNAME": "your_username",
          "TAIGA_PASSWORD": "your_password"
        }
      }
    }
  }
}

JetBrains IDEs

Open Settings → Tools → AI Assistant → MCP (or the dedicated MCP settings page in newer releases), click Add, choose As JSON, and paste:

{
  "mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

Requires the AI Assistant plugin with MCP support enabled.

Gemini CLI

Edit ~/.gemini/settings.json and restart the CLI. Tools require confirmation per call unless you allowlist them:

{
  "mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      },
      "includeTools": ["projects", "work", "sprints", "comments", "attachments", "wiki"]
    }
  }
}

Check registration with /mcp list inside the CLI.

Codex CLI

Add a server table to ~/.codex/config.toml:

[mcp_servers.taiga]
command = "npx"
args = ["-y", "mcp-taiga"]

[mcp_servers.taiga.env]
TAIGA_USERNAME = "your_username"
TAIGA_PASSWORD = "your_password"

Verify with codex mcp list; tools appear as taiga_* inside sessions.

opencode

Add to opencode.json (project root or ~/.config/opencode/opencode.json):

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "taiga": {
      "type": "local",
      "command": ["npx", "-y", "mcp-taiga"],
      "environment": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      },
      "enabled": true
    }
  }
}

Note the singular environment key and array-form command, which differ from the Claude-style schema.

Amp

Prefer the CLI for user-scope servers:

amp mcp add taiga -- npx -y mcp-taiga

Or declare amp.mcpServers in ~/.config/amp/settings.json (workspace .amp/settings.json variants require running amp mcp approve taiga first):

{
  "amp.mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

Pi

Pi reads Claude-style MCP config from two scopes: ~/.pi/agent/mcp.json (user) and .mcp.json or mcp.json in the working directory (project). Edit the user file:

{
  "mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

Remote servers use "url" plus "transport": "http". Manage servers with /mcp inside a session (/mcp add, /mcp list, enable/disable per server).

This repository ships its own .mcp.json, so launching pi inside a local checkout picks up the local build automatically (no credentials needed there — the server loads the repo .env).

Oh My Pi

omp shares pi's agent core but has its own config root. Edit ~/.omp/agent/mcp.json:

{
  "mcpServers": {
    "taiga": {
      "command": "npx",
      "args": ["-y", "mcp-taiga"],
      "env": {
        "TAIGA_USERNAME": "your_username",
        "TAIGA_PASSWORD": "your_password"
      }
    }
  }
}

MCP servers bind when the session is constructed — restart omp after editing. Tools surface as taiga_* entries; project-level configs follow pi's discovery (including this repo's checked-in .mcp.json).

Remote and Web Clients (HTTP Transport)

Set TAIGA_HTTP_PORT to expose the same six tools over streamable HTTP instead of stdio — useful for clients that cannot spawn local processes, or for running one shared instance:

TAIGA_HTTP_PORT=3000 npx -y mcp-taiga
# serves http://127.0.0.1:3000/mcp

Properties: stateless mode (no session headers), bound to 127.0.0.1 unless TAIGA_HTTP_HOST overrides it (non-loopback binds print a plaintext-HTTP warning to stderr), DNS-rebinding protection enabled for the advertised host, malformed JSON rejected with -32700, non-POST methods on /mcp answered 405.

Clients connect by URL rather than command:

{
  "mcpServers": {
    "taiga": {
      "url": "http://127.0.0.1:3000/mcp"
    }
  }
}

Continue.dev equivalent: type: streamable-http with url:; opencode: type: "remote" with url:. Because the process is launched manually rather than by the client, export TAIGA_USERNAME/TAIGA_PASSWORD in that shell (or use a systemd unit, container, etc.).

Containers

The included two-stage Dockerfile uses Node 22 Alpine with a non-root node user. The build stage compiles the TypeScript source, and the runtime stage packages only the compiled dist/src output and production dependencies.

Build the container image:

docker build -t mcp-taiga .

Run the container attached to standard I/O:

docker run --rm -i --env-file .env mcp-taiga

Podman works by direct substitution: replace docker with podman in the commands above.

Point an MCP client configuration at the container runner:

{
  "mcpServers": {
    "taiga": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "--env-file", "/absolute/path/to/.env", "mcp-taiga"]
    }
  }
}

For an HTTP deployment, publish the port instead: docker run --rm -p 127.0.0.1:3000:3000 -e TAIGA_HTTP_PORT=3000 --env-file .env mcp-taiga and point URL-based clients at http://127.0.0.1:3000/mcp.

There is deliberately no compose file. An MCP stdio server must be spawned attached directly to its client's stdin and stdout streams, and exits when that stdin stream closes. Process supervisors or compose setups that attempt to keep long-running background services alive cause infinite restart loops and container name conflicts.

Conventions

Projects: Project arguments accept a numeric project ID (e.g. 19) or a slug (e.g. "acme-web").
Work Items: Work items accept a numeric database ID (e.g. 1888) or a reference prefixed with hash (e.g. "#70"). A #reference requires the project argument to resolve.
People: Member arguments accept a numeric user ID, username (e.g. "jdoe"), full name (e.g. "Jane Doe"), or the literal "me".
Taxonomies: Statuses, priorities, severities, issue types, and sprint names accept human-readable names and are resolved to numeric IDs server-side.
Multi-Assignee User Stories: Taiga user stories support multiple assignees via assigned_users. Filtering by assignee on work list type:story matches co-assignees, and listings display all assignees rather than only the primary.
Dense Text Results: Results are plain text formatted with one dense line per record or clean key-value blocks for detail views. No consumer reads structuredContent, so results are text only. An empty collection is reported as <items> in <project>: 0 rather than an error.
Full Collections: List endpoints return complete collections because the client sends the x-disable-pagination: true request header, eliminating multi-page roundtrips.

Why Six Tools

Single-purpose tool proliferation creates substantial context window overhead before any tool is invoked. Consolidating functionality into 6 op-dispatching domain tools keeps the tools/list payload to about 10,493 characters (~2,800 tokens).

Output schemas are deliberately absent from tool registrations: MCP client bridges concatenate text content and ignore outputSchema and structuredContent, so omitting output schemas eliminates unnecessary token overhead on session startup.

Tool Reference

The server exposes 6 tools covering 28 operation pairs.

1. `projects`

List or inspect Taiga projects and verify credentials.

Op	What it does	Required args	Optional args
`list`	List projects where authenticated user is a member	(none)	(none)
`get`	Inspect project metadata, owner, member count, active modules	`project`	(none)
`whoami`	Verify credentials and show current user info	(none)	(none)

2. `work`

Manage issues, user stories, tasks, and epics (type: issue, story, task, epic).

Op	What it does	Required args	Optional args
`list`	List work items with server-side filters	`type`, `project`	`assignee`, `watcher`, `sprint`, `status`, `tags`, `closed`, `q`, `orderBy`, `limit`, `parent` (tasks)
`get`	Get complete details and description for a work item	`type`, `item`	`project` (required if item is `#ref`)
`create`	Create a single work item or batch items	`type`, `project`, `subject` (or `items` for batch; tasks require `parent`)	`description`, `status`, `assignee`, `sprint`, `tags`, `priority` (issue), `severity` (issue), `issueType` (issue), `points` (story), `parent` (epic for story / default for batch), `items` (max 20)
`update`	Update fields on an existing work item	`type`, `item`	`project` (required if item is `#ref`), `subject`, `description`, `status`, `assignee`, `sprint`, `tags`, `priority`, `severity`, `issueType`, `points`
`link`	Link a user story to an epic	`type` (`story`), `item` (story), `parent` (epic)	`project` (required if item or parent is `#ref`)
`unlink`	Remove a user story from an epic	`type` (`story`), `item` (story), `parent` (epic)	`project` (required if item or parent is `#ref`)
`delete`	Permanently delete a single work item	`type`, `item`	`project` (required if item is `#ref`)

3. `sprints`

Manage sprints (milestones) and inspect progress statistics.

Op	What it does	Required args	Optional args
`list`	List sprints in a project	`project`	(none)
`get`	Get sprint details and assigned user stories	`sprint`	`project` (required if sprint is a name)
`create`	Create a new sprint milestone	`project`, `name`	`start` (YYYY-MM-DD), `finish` (YYYY-MM-DD)
`stats`	Get sprint progress statistics and completion metrics	`sprint`	`project` (required if sprint is a name)

Sprint deletion is intentionally not exposed: removing a milestone detaches every story and task on it, making it a board-wide edit that belongs in the Taiga UI.

4. `comments`

List, add, edit, or delete comments on work items and wiki pages (type: issue, story, task, epic, wiki).

Op	What it does	Required args	Optional args
`list`	List comments oldest first	`type`, `item`	`project` (required for `#ref` or wiki slug), `includeDeleted`
`add`	Add a comment to an item	`type`, `item`, `text`	`project` (required for `#ref` or wiki slug)
`edit`	Edit an existing comment by UUID	`type`, `item`, `commentId`, `text`	`project` (required for `#ref` or wiki slug)
`delete`	Soft-delete a comment by UUID	`type`, `item`, `commentId`	`project` (required for `#ref` or wiki slug)

5. `attachments`

Manage file attachments on work items and wiki pages (type: issue, story, task, epic, wiki).

Op	What it does	Required args	Optional args
`list`	List attachments on an item	`type`, `item`	`project` (required for `#ref` or wiki slug)
`upload`	Upload a file from local path or base64	`type`, `item`, `filePath` or `fileContent`	`project`, `fileName`, `mimeType`, `description`
`download`	Fetch attachment metadata; optionally writes file to disk	`type`, `attachmentId`	`savePath` (path to save downloaded file)
`delete`	Permanently delete an attachment	`type`, `attachmentId`	(none)

6. `wiki`

Manage wiki pages and page subscriptions within a project.

Op	What it does	Required args	Optional args
`list`	List all wiki pages in a project	`project`	(none)
`get`	Inspect wiki page metadata and Markdown content	`page` (ID or slug)	`project` (required if page is a slug)
`create`	Create a new wiki page	`project`, `page` (slug)	`content`
`update`	Update wiki page content	`page` (ID or slug), `content`	`project` (required if page is a slug)
`delete`	Permanently delete a wiki page	`page` (ID or slug)	`project` (required if page is a slug)
`watch`	Watch or unwatch a wiki page	`page` (ID or slug)	`project` (required if page is a slug), `watch` (boolean, default true)

Reliability and Safety

Rate Limiting (429): The server retries HTTP 429 responses at most twice, honoring the server Retry-After header. If the required wait exceeds the 5-second ceiling (MAX_THROTTLE_WAIT_MS), it throws immediately with a retry message instead of sleeping.
5xx Errors Never Retried: 5xx responses are never retried automatically because mutating requests (such as POST) may have already been applied on the server; repeating them risks creating duplicate records.
Metadata Cache: Project metadata (slug lookups, user memberships, and taxonomy lists for statuses, priorities, severities, and issue types) is cached for 60 seconds (METADATA_TTL_MS) via getMetadata. Work items, comments, and attachments are never cached.
Timeouts: HTTP requests enforce a 30-second timeout (REQUEST_TIMEOUT_MS).
HTTPS Enforcement: The server emits a warning to stderr if TAIGA_API_URL uses unencrypted HTTP to a non-loopback host.
Restricted Attachment Downloads: Attachment downloads are restricted strictly to the configured Taiga hostname with no redirects allowed (maxRedirects: 0), bounded to a maximum file size of 10 MB (MAX_ATTACHMENT_BYTES). The download request does not send the Taiga bearer token to media hosts.
File Overwrite Protection: Attachment download with savePath refuses to overwrite an existing local file.
Single-Target Deletions: Deletion operations accept exactly one target at a time. Batch operations are create-only (up to 20 items), preventing accidental board-wide deletions.

Security Considerations

Credentials travel via environment variables or harness config files, never command-line arguments (which leak through process lists) and never the repository. Keep harness config files containing inline passwords out of version control; .gitignore already excludes .env* except .env.example.
The optional HTTP transport binds to loopback by default and enables DNS-rebinding protection; binding to a routable address prints a warning because traffic is unencrypted.
Attachment downloads never carry your bearer token off the Taiga hostname, refuse redirects, cap file size, and refuse to overwrite existing files.
Deletion surfaces are single-target by design; there are no batch deletes.

FAQ

Which MCP clients can use it? Anything that speaks stdio MCP — the installation guide covers seventeen of them with copy-paste configs — plus URL-based clients through the HTTP transport.

Does it work with self-hosted Taiga? Yes. Set TAIGA_API_URL to your instance including the /api/v1 suffix (e.g. https://taiga.example.com/api/v1). Everything else behaves identically; if requests 404, see Troubleshooting.

Can I connect more than one Taiga account or instance? Not within one server process — it holds exactly one credential set, read from the environment at startup. Register additional entries under mcpServers (e.g. "taiga-work") with their own env values; each becomes an independent tool namespace like mcp__taiga-work__work.

Where does my password go? From your env block into memory, and from there only to the configured Taiga host during the login exchange — never to command lines (which leak via process lists), logs, tool results, or attachment download hosts. See Security Considerations.

Is it read-only? No: full create, update, link/unlink, and delete across work items, sprints, comments, attachments, and wiki pages. Sprint deletion and batch deletion are deliberately absent — see Reliability and Safety.

Why only six tools when other MCP servers expose dozens? Context-window economics: every tool definition is paid on every session start. See Why Six Tools.

Something broke — where do I start? Troubleshooting covers the common failure modes; beyond that, open a GitHub issue with the failing tool call and the server's stderr output.

Troubleshooting

Authentication failures — run the projects tool with op: whoami; it reports exactly which credential exchange failed. Check for stray whitespace in env values and that the account works in the Taiga web UI.
Self-hosted instance returns 404s — TAIGA_API_URL must include /api/v1, e.g. https://taiga.example.com/api/v1.
Server starts but npx client sees no tools — confirm Node.js >= 20.11 runs in the harness's environment; GUI launchers often inherit a different PATH than your shell.
Credentials ignored under npx — npx installs do not load .env; put credentials in the harness env block (only local checkouts auto-load .env).
HTTP mode port conflicts — another process owns the port; pick another TAIGA_HTTP_PORT. The server exits nonzero with a listen error rather than retrying.
Empty result sets — listings report <items> in <project>: 0; that is a successful response, not an error.
Cursor/Windsurf server present but idle — toggle the server enabled switch in the respective settings panel after editing config files; both cache state until refreshed.

Development

File Layout

src/index.ts            # Entrypoint: createServer() factory, stdio vs HTTP transport selection
src/http.ts             # Streamable HTTP transport (node:http, stateless, DNS-rebinding protected)
src/api.ts              # Authenticated axios transport, generic HTTP helpers (get, post, patch, del), token management, retry policy, metadata cache
src/taiga.ts            # Domain helpers: resolution (projects, items, members, taxonomies, sprints) and optimistic concurrency patch
src/types.ts            # Taiga payload interfaces, tool definitions, and type contracts
src/format.ts           # Dense pipe-separated single-line renderers and detail views
src/utils.ts            # MCP response builders (createSuccessResponse, createErrorResponse, guard) and formatting helpers
src/constants.ts        # Endpoints, limits (batch size, attachment size), status labels, error messages
src/tools/index.ts      # Tool registry aggregating all tools and registering with McpServer
src/tools/projects.ts   # projects tool (list, get, whoami)
src/tools/work.ts       # work tool (list, get, create, update, link, unlink, delete across issues, stories, tasks, epics)
src/tools/sprints.ts    # sprints tool (list, get, create, stats)
src/tools/comments.ts   # comments tool (list, add, edit, delete)
src/tools/attachments.ts # attachments tool (list, upload, download, delete)
src/tools/wiki.ts       # wiki tool (list, get, create, update, delete, watch)
test/unitTest.ts        # Offline unit tests for pure helpers, formatting functions, response builders, and tool invariants
test/protocolTest.ts    # Protocol tests verifying MCP stdio handshake, server capabilities, tool count, and tools/list budget
test/httpTest.ts        # Transport tests verifying the streamable HTTP endpoint: handshake, tools/list, routing rejections
test/apiContractTest.ts # Contract tests driving every tool op against an in-process mock Taiga HTTP server, asserting outgoing HTTP requests
test/integration.ts     # Live integration smoke test against a real Taiga instance (read-only, skips without credentials)

NPM Scripts

npm run build: Compiles TypeScript from src/ and test/ into dist/ via tsc.
npm run check: Type-checks TypeScript code without emitting output (tsc --noEmit).
npm run lint: Runs oxlint across src/ and test/.
npm start: Runs the compiled server (node dist/src/index.js).
npm test: Compiles and runs unit, protocol, contract, and HTTP transport test suites in sequence.
npm run test:unit: Compiles and runs offline unit tests.
npm run test:protocol: Compiles and runs MCP protocol tests over stdio.
npm run test:http: Compiles and runs streamable HTTP transport tests.
npm run test:contract: Compiles and runs API contract tests against the mock Taiga server.
npm run test:integration: Compiles and runs live integration tests against a live instance.
npm run prepublishOnly: Runs type check, linting, and full test suite before publishing.

Test Suites

Unit Tests (test/unitTest.ts): Offline unit tests asserting pure formatting functions, response builders, identifier resolution helpers, and tool-definition invariants without network calls or credentials.
Protocol Tests (test/protocolTest.ts): Protocol tests asserting the real MCP stdio handshake, server version and capabilities, tool schemas, and the tools/list character budget against a spawned server process.
HTTP Tests (test/httpTest.ts): Spawns the compiled server with TAIGA_HTTP_PORT and asserts the real streamable HTTP handshake, protocol-version echo, stateless behavior, tools/list contents, and 400/404/405 routing rejections over localhost.
Contract Tests (test/apiContractTest.ts): Contract tests asserting that every tool and op sends the expected outgoing HTTP requests (method, endpoint, query parameters, headers, and payload) and processes responses against an in-process mock Taiga HTTP server.
Integration Tests (test/integration.ts): Live integration smoke tests asserting read-only tool operations against a real Taiga instance over stdio (skipped when credentials are not configured).

Contributing

Pull requests target dev; see CONTRIBUTING.md for the branch model (dev → staging → main), commit conventions, and the release process.

Changelog

See CHANGELOG.md.

License

MIT

Available Tools

6 tools

attachmentsAttachmentsA

Destructive

List, upload, download, or delete attachments across work items and wiki pages.

op	required args	optional args	notes
list	type, item	project	List attachments on a work item or wiki page
upload	type, item, filePath OR fileContent	project, fileName, mimeType, description	Upload file to Taiga host from local path (harness resolves local:// URIs) or base64
download	type, attachmentId	savePath	Fetch metadata and bytes; writes to savePath when given
delete	type, attachmentId		Delete attachment by ID

ParametersJSON Schema

Name	Required	Description
`op`	Yes	Operation to perform: list, upload, download, delete
`item`	No	Item numeric ID, #ref, or wiki slug
`type`	No	Target item type (issue, story, task, epic, wiki)
`project`	No	Project ID or slug (required for #ref or wiki slug)
`fileName`	No	File name including extension
`filePath`	No	Local file path on the machine running this server to upload to the Taiga host (the omp harness resolves local:// URIs to filesystem paths before invoking this tool)
`mimeType`	No	MIME type of uploaded file
`savePath`	No	Local filesystem path to save downloaded file
`description`	No	Attachment description text
`fileContent`	No	Base64-encoded file content to upload
`attachmentId`	No	Attachment ID for download or delete

TDQS

A4.4/5.0

Behavior4/5

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

The description adds helpful behavioral details beyond the annotations: download writes files to savePath when provided, and upload resolves local:// URIs through the harness. The destructiveHint annotation is consistent with the delete operation, and no annotation contradiction exists.

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 compact, well organized, and front-loads the core purpose in one clause. The table conveys a large amount of operation-parameter information without unnecessary prose, and every line adds utility.

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?

The tool has many parameters and a multi-operation structure, but the operation table plus schema descriptions cover the calling requirements well. It could offer more on return shapes, permissions, or side effects, though it remains sufficient for reliable invocation.

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 of 100 percent means baseline is 3, but the description still adds meaningful value through a required/optional argument matrix per operation. It clarifies the relationship between operation and parameter choice, especially the 'filePath OR fileContent' upload requirement.

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 a precise verb set — 'List, upload, download, or delete attachments' — and scopes it to 'work items and wiki pages.' The operation table further disambiguates each action, and the tool name plus resource clearly separates it from sibling tools like comments and wiki.

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?

The table gives clear operational context by mapping each op to required and optional arguments. It implicitly tells the agent when to use an operation but does not explicitly discuss exclusions or mention specific sibling alternatives for choosing between tools.

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

commentsCommentsA

Destructive

List, add, edit, or delete comments on issues, user stories, tasks, epics, and wiki pages. Note: Taiga soft-deletes comments on delete.

ParametersJSON Schema

Name	Required	Description
`op`	Yes	Operation to perform
`item`	No	Item ID, #reference, or wiki slug
`text`	No	Comment markdown text (add, edit)
`type`	No	Item type
`project`	No	Project ID or slug (required for #ref or wiki slug)
`commentId`	No	Comment UUID (edit, delete)
`includeDeleted`	No	Include soft-deleted comments (list)

TDQS

A4.7/5.0

Behavior5/5

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

Beyond the annotations, the description reveals a key behavioral nuance: 'Taiga soft-deletes comments on delete'. This explains how deletes behave and makes the includeDeleted parameter meaningful. It also implies deletion might be reversible, which adds context not available from the annotations alone.

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 introductory sentence followed by a compact, readable table. Every piece of content in the table contributes to understanding operation-specific argument requirements, with no fluff or repetition of schema details. The purpose is front-loaded in the first clause.

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

Completeness5/5

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

Given the tool's complexity (7 params, no output schema, 4 operations), the description provides a complete operation-by-operation breakdown of required and optional arguments. The soft-delete note and the includeDeleted parameter are explained in a way that leaves nothing ambiguous.

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?

The schema already covers all parameter descriptions (100% coverage), so the baseline is 3. The description's operation matrix adds value by showing which parameters are conditionally required for each 'op' (e.g., commentId only for edit/delete, text only for add/edit), which the schema does not convey. This extra relational information raises the score above baseline.

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 a clear verb phrase ('List, add, edit, or delete') and names the exact resource types (issues, user stories, tasks, epics, wiki pages). It unambiguously identifies this tool as the comment-handling tool, separating it from siblings like 'attachments' and 'wiki'.

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?

The operation table gives explicit guidance on which arguments are required for each operation (list vs. add vs. edit vs. delete), helping an agent assemble calls correctly. It lacks an explicit statement of when not to use this tool, but the operations are self-explanatory and no true alternative exists among the listed siblings.

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

projectsProjectsA

Read-onlyIdempotent

List or inspect Taiga projects and verify credentials.

Credentials come from TAIGA_USERNAME and TAIGA_PASSWORD in the environment; the server authenticates on first use. Use whoami to verify them.

op	required args	optional args	notes
list			List projects where authenticated user is member
get	project		Inspect project metadata, owner, member count, active modules
whoami			Verify credentials and show current user info

ParametersJSON Schema

Name	Required	Description	Default
`op`	Yes	Operation to perform: list, get, or whoami
`project`	No	Project ID or slug (required for get)

TDQS

A4.4/5.0

Behavior4/5

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

Annotations already declare readOnly/idempotent/openWorld hints. The description adds behavioral context: credentials are sourced from environment variables and authentication occurs on first use. This explains the tool's interaction with external state without contradicting the 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?

The description is compact and well-structured, using a table to organize the three operations. No redundant sentences; all content is informative.

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?

With no output schema, the description briefly indicates return types (e.g., 'list projects', 'inspect metadata, owner, member count', 'show current user info'), which is sufficient for a read-only tool. It covers credential handling and operation-specific arguments effectively.

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?

The input schema already describes op and project (100% coverage). The description goes further by mapping each operation to its required/optional arguments, clarifying that get needs project while list and whoami don't, which is not evident from the schema alone.

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 explicitly states 'List or inspect Taiga projects and verify credentials' and then enumerates three operations (list, get, whoami) in a structured table, making the tool's purpose unmistakable and distinct from siblings like sprints or work.

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 explicit guidance to use the whoami operation for credential verification, and the table indicates when each op applies (e.g., get for inspecting a specific project's metadata). While it doesn't name sibling alternatives, the resource-specific scope makes the use case clear.

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

sprintsSprintsA

Manage Taiga sprints (milestones): list, inspect, create, or fetch statistics.

Operations:

list: List sprints in a project. Requires project.
get: Get sprint details and assigned stories. Requires sprint (ID or name); project required if sprint is a name.
stats: Get sprint progress statistics and metrics. Requires sprint; project required if sprint is a name.

Sprint deletion is intentionally not exposed: removing a milestone detaches every story and task on it, so it is a board-wide edit that belongs in the Taiga UI. Delete individual work items with the work tool instead.

ParametersJSON Schema

Name	Required	Description
`op`	Yes	Operation to perform
`name`	No	Sprint name (for create)
`start`	No	Start date YYYY-MM-DD (for create)
`finish`	No	Finish date YYYY-MM-DD (for create)
`sprint`	No	Sprint ID or name (for get, stats)
`project`	No	Project ID or slug

TDQS

A4.7/5.0

Behavior4/5

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

Annotations indicate non-read-only, non-destructive, open-world. The description adds valuable context that sprint deletion is intentionally not exposed because it detaches all stories/tasks, a board-wide edit better done in the UI. This goes beyond annotations by explaining the design rationale, though it does not detail auth or rate limits.

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 well-structured with a brief overview and bullet-pointed operations. Every line provides necessary information without redundancy or fluff.

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

Completeness5/5

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

Despite no output schema, the description covers all operations, required parameters, exclusions (deletion), and points to the correct sibling tool for related actions. It is sufficiently complete for an agent to select and invoke the tool.

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 covers 100% of parameters with descriptions. The description adds operational context (e.g., which parameters are required for which op, project needed when sprint is a name) beyond the schema, improving the agent's ability to invoke the tool correctly.

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 it manages Taiga sprints with specific operations (list, get, create, stats). It distinguishes from siblings by explicitly mentioning the work tool for deletion and implying project tool for project-level tasks.

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

Usage Guidelines5/5

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

Provides explicit operation-specific prerequisites (e.g., 'Requires project' for list, 'project required if sprint is a name' for get/stats). Also gives an alternative: 'Delete individual work items with the work tool instead' when discussing deletion.

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

wikiWikiA

Destructive

Create, inspect, update, delete, or watch wiki pages in a project.

op	required args	optional args	notes
list	project		List all wiki pages in project
get	page	project	Inspect wiki page metadata and content; project needed if page is slug
create	project, page	content	Create wiki page; page is the slug
update	page, content	project	Update wiki page content (OCC versioned); project needed if page is slug
delete	page	project	Delete wiki page permanently; project needed if page is slug
watch	page	project, watch	Watch (default) or unwatch wiki page; project needed if page is slug

ParametersJSON Schema

Name	Required	Description
`op`	Yes	Operation to perform: list, get, create, update, delete, watch
`page`	No	Wiki page ID or slug
`watch`	No	True to watch, false to unwatch (default true)
`content`	No	Wiki page content in Markdown
`project`	No	Project ID or slug

TDQS

A4.6/5.0

Behavior5/5

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

The description exposes meaningful behavior beyond the annotations: delete is described as permanent, update is described as OCC versioned, watch defaults to true, and list/get inspect metadata and content. This goes well beyond the bare readOnlyHint=false and destructiveHint=true annotations.

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

Conciseness4/5

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

The operation table is a compact and scannable way to present six different modes in one tool. It is mainly efficient, although the repeated 'project needed if page is slug' note could be consolidated; still, the structure gives high clarity without unnecessary prose.

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?

The description is highly complete for selecting and invoking each operation because it maps required args, slugs, content format, watch default, and destructive flag. With no output schema, a little more detail about the actual returned data shape would round it out, but the agent can safely and correctly call the tool.

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

Parameters5/5

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

The table adds per-operation required/optional semantics beyond the raw schema, clarifies page as ID/slug, and explains when project is needed. It also documents content as Markdown and watch default behavior, so an agent can invoke each operation correctly without guessing parameter combinations.

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 begins with a clear action list—'Create, inspect, update, delete, or watch wiki pages'—and then concretely defines each operation against the wiki page resource. This makes the tool's scope unambiguous and keeps the list/get/create/update/delete/watch overloaded operation distinct from sibling resource tools.

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?

The operation table gives explicit routing for each op and states which arguments are required versus optional, including the important condition that project is needed when page is a slug. It does not explicitly contrast the tool with sibling tools, but the table provides sufficient when-to-use guidance for each operation.

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

workWork itemsA

Destructive

Manage Taiga work items (issues, user stories, tasks, epics).

Operations:

list: List items with optional filters (project required).
get: Get details for a single item (item required).
create: Create one item or batch items (project and subject/items required).
update: Modify fields on an item (item required).
link: Link a user story to an epic (type: story, item: story, parent: epic required).
unlink: Remove a user story from an epic (type: story, item: story, parent: epic required).
delete: Permanently delete ONE item (item required). Taiga has no trash for work items, so this cannot be undone. Batch is deliberately create-only: up to 20 items can be created in a call, exactly one can be deleted, so a mistaken call cannot clear a board.

ParametersJSON Schema

Name	Required	Description
`q`	No	Full-text search query
`op`	Yes	Operation to perform
`item`	No	Item numeric ID or #ref
`tags`	No	Tags array
`type`	Yes	Work item type
`items`	No	Batch create items array (max 20)
`limit`	No	Maximum number of items to return
`closed`	No	Filter by closed state
`parent`	No	Parent story (tasks) or epic (link/unlink)
`points`	No	Points value matching project point deck (e.g. 1, 3, 5, or "?" for unestimated; stories only)
`sprint`	No	Sprint ID or name ("none" to clear)
`status`	No	Status name
`orderBy`	No	Order by field, prefix "-" for desc
`project`	No	Project ID or slug
`subject`	No	Item subject or title
`watcher`	No	Filter by watcher username, email, or "me"
`assignee`	No	Assignee username, email, full name, ID, or "me"
`priority`	No	Priority name (issues only)
`severity`	No	Severity name (issues only)
`issueType`	No	Issue type name (issues only)
`description`	No	Item description markdown

TDQS

A4.5/5.0

Behavior5/5

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

The description explicitly warns that delete is permanent and that Taiga has no trash, and explains the batch create-only safeguard prevents accidental board clearing. This adds substantial safety context beyond the destructiveHint annotation, and there is no contradiction 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?

The description is compact and well-structured, starting with a one-line summary followed by a bulleted list of operations. Every sentence provides operational guidance, with no filler or redundant information.

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

Completeness5/5

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

All seven operations have their required parameters stated, the delete behavior carries a detailed permanence warning with rationale, and the batch limit is explicitly noted. Without an output schema, this description sufficiently covers invocation semantics for a complex 21-parameter 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 100%, so all 21 parameters already have descriptions. The tool description only reiterates which parameters are required for specific operations (e.g., project required) without adding new semantic meaning. The schema carries the parameter documentation burden.

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 states 'Manage Taiga work items (issues, user stories, tasks, epics)' and enumerates seven distinct operations with specific verbs (list, get, create, update, link, unlink, delete). This makes the tool's purpose unambiguous and clearly distinguishes it from sibling tools like projects, sprints, and wiki.

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?

The operation list provides clear context with required parameters for each operation (e.g., 'project required', 'item required') and includes a safety warning about delete being permanent. However, it does not explicitly state when to use this tool over alternatives, though the separation from siblings is implicit in the description.

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. Dates show when Glama detected each change.

6 tool updatesv1.0.0Aug 17, 2026
- First observedattachments
- First observedcomments
- First observedprojects
- First observedsprints
- First observedwiki
- First observedwork

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.5/5.0

Disambiguation5/5

Each tool maps to a distinct Taiga resource: projects, work items, sprints, comments, attachments, and wiki. Shared type/item parameters are used for child resources, but the tool purposes do not overlap.

Naming Consistency4/5

Top-level tool names are simple lowercase resource nouns and are internally consistent. The pattern is slightly mixed because some names are plural resources while work and wiki are singular, and the internal op verbs vary between add/create and edit/update.

Tool Count5/5

Six resource-scoped tools is a well-balanced surface for a project-management server. Each tool represents a meaningful functional area without making the tool list overwhelming.

Completeness4/5

The server covers most core workflows: project inspection, work-item CRUD, sprints, comments, attachments, and wiki with lifecycle operations. Deliberate gaps such as project creation/deletion and sprint update/delete prevent it from being fully complete.

Maintenance

ActivityMaintained

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

mcp-serverOAuth
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2
mcpOAuth
net.todoist
Official Todoist MCP server for AI assistants to manage tasks, projects, and workflows.
App Automation Workplace & Productivity Project Management
2
Testiny Test ManagementOAuth
io.testiny
An MCP server that provides access to Testiny projects, test cases and test runs
Testing & QA Tools Project Management
2
Kangram
app.kangram
Task & board management for AI agents + humans. Kanban, comments, digests via MCP.
Project Management
1

Related MCP Servers

Taiga MCP Server
Project Management Workplace & Productivity
jafamo
A
license
B
quality
C
maintenance
Enables LLMs to manage Taiga projects, sprints, user stories, tasks, issues, epics, and wiki pages via natural language.
Updated 5 months ago (2026-03-26 07:53 UTC)
31
42
MIT
@illodev/taiga-mcp
Project Management Developer Tools
illodev
A
license
B
quality
D
maintenance
Full-featured MCP server for Taiga project management, enabling AI agents to manage projects, epics, user stories, tasks, issues, sprints, wiki pages, memberships, and roles via Taiga API v1.
Updated 5 months ago (2026-03-26 09:27 UTC)
100
46
2
MIT
taiga-mcp
Project Management Developer Tools
juanleon8581
A
license
A
quality
B
maintenance
MCP server for the Taiga project management API. Enables AI assistants to manage projects, issues, user stories, tasks, epics, sprints, and wiki pages via natural language commands.
Updated 24 days ago (2026-08-12 21:07 UTC)
55
12
ISC
zube-mcp
reenrik
F
license
C
quality
D
maintenance
MCP server for the Zube.io project management API, exposing boards, cards, epics, tickets, sprints, and workspaces as tools for AI assistants.
Updated 5 months ago (2026-03-31 19:54 UTC)
42
-

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/negoro26/mcp-taiga'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Taiga MCP Server

Contents

Features

Requirements and Configuration

Quick Start

Running From a Local Checkout

Installation and Configuration

Claude Code

Claude Desktop

VS Code and GitHub Copilot

Cursor

Windsurf

Cline, Roo Code, and Kilo Code

Continue.dev

Zed

JetBrains IDEs

Gemini CLI

Codex CLI

opencode

Amp

Pi

Oh My Pi

Remote and Web Clients (HTTP Transport)

Containers

Conventions

Why Six Tools

Tool Reference

1. projects

2. work

3. sprints

4. comments

5. attachments

6. wiki

Reliability and Safety

Security Considerations

FAQ

Troubleshooting

Development

File Layout

NPM Scripts

Test Suites

Contributing

Changelog

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

1. `projects`

2. `work`

3. `sprints`

4. `comments`

5. `attachments`

6. `wiki`