Yandex Tracker

Configuration file path:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Using uvx:

{
  "mcpServers": {
    "yandex-tracker": {
      "command": "uvx",
      "args": ["yandex-tracker-mcp@latest"],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

Using Docker:

{
  "mcpServers": {
    "yandex-tracker": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "TRACKER_TOKEN",
        "-e", "TRACKER_CLOUD_ORG_ID",
        "ghcr.io/aikts/yandex-tracker-mcp:latest"
      ],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

Using uvx:

claude mcp add yandex-tracker uvx yandex-tracker-mcp@latest \
  -e TRACKER_TOKEN=your_tracker_token_here \
  -e TRACKER_CLOUD_ORG_ID=your_cloud_org_id_here \
  -e TRANSPORT=stdio

Using Docker:

claude mcp add yandex-tracker docker "run --rm -i -e TRACKER_TOKEN=your_tracker_token_here -e TRACKER_CLOUD_ORG_ID=your_cloud_org_id_here -e TRANSPORT=stdio ghcr.io/aikts/yandex-tracker-mcp:latest"

Configuration file path:

• Project-specific: .cursor/mcp.json in your project directory
• Global: ~/.cursor/mcp.json

Using uvx:

{
  "mcpServers": {
    "yandex-tracker": {
      "command": "uvx",
      "args": ["yandex-tracker-mcp@latest"],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

Using Docker:

{
  "mcpServers": {
    "yandex-tracker": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "TRACKER_TOKEN",
        "-e", "TRACKER_CLOUD_ORG_ID",
        "ghcr.io/aikts/yandex-tracker-mcp:latest"
      ],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

Configuration file path:

• ~/.codeium/windsurf/mcp_config.json

Access via: Windsurf Settings → Cascade tab → Model Context Protocol (MCP) Servers → "View raw config"

Using uvx:

{
  "mcpServers": {
    "yandex-tracker": {
      "command": "uvx",
      "args": ["yandex-tracker-mcp@latest"],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

Using Docker:

{
  "mcpServers": {
    "yandex-tracker": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "TRACKER_TOKEN",
        "-e", "TRACKER_CLOUD_ORG_ID",
        "ghcr.io/aikts/yandex-tracker-mcp:latest"
      ],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

Configuration file path:

• ~/.config/zed/settings.json

Access via: Cmd+, (macOS) or Ctrl+, (Linux/Windows) or command palette: "zed: open settings"

Note: Requires Zed Preview version for MCP support.

Using uvx:

{
  "context_servers": {
    "yandex-tracker": {
      "source": "custom",
      "command": {
        "path": "uvx",
        "args": ["yandex-tracker-mcp@latest"],
        "env": {
          "TRACKER_TOKEN": "your_tracker_token_here",
          "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
        }
      }
    }
  }
}

Using Docker:

{
  "context_servers": {
    "yandex-tracker": {
      "source": "custom",
      "command": {
        "path": "docker",
        "args": [
          "run", "--rm", "-i",
          "-e", "TRACKER_TOKEN",
          "-e", "TRACKER_CLOUD_ORG_ID",
          "ghcr.io/aikts/yandex-tracker-mcp:latest"
        ],
        "env": {
          "TRACKER_TOKEN": "your_tracker_token_here",
          "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
        }
      }
    }
  }
}

Configuration file path:

• Workspace: .vscode/mcp.json in your project directory
• Global: VS Code settings.json

Option 1: Workspace Configuration (Recommended for security)

Create .vscode/mcp.json:

Using uvx:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "tracker-token",
      "description": "Yandex Tracker Token",
      "password": true
    },
    {
      "type": "promptString",
      "id": "cloud-org-id",
      "description": "Yandex Cloud Organization ID"
    }
  ],
  "servers": {
    "yandex-tracker": {
      "type": "stdio",
      "command": "uvx",
      "args": ["yandex-tracker-mcp@latest"],
      "env": {
        "TRACKER_TOKEN": "${input:tracker-token}",
        "TRACKER_CLOUD_ORG_ID": "${input:cloud-org-id}",
        "TRANSPORT": "stdio"
      }
    }
  }
}

Using Docker:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "tracker-token",
      "description": "Yandex Tracker Token",
      "password": true
    },
    {
      "type": "promptString",
      "id": "cloud-org-id",
      "description": "Yandex Cloud Organization ID"
    }
  ],
  "servers": {
    "yandex-tracker": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "TRACKER_TOKEN",
        "-e", "TRACKER_CLOUD_ORG_ID",
        "ghcr.io/aikts/yandex-tracker-mcp:latest"
      ],
      "env": {
        "TRACKER_TOKEN": "${input:tracker-token}",
        "TRACKER_CLOUD_ORG_ID": "${input:cloud-org-id}",
        "TRANSPORT": "stdio"
      }
    }
  }
}

Option 2: Global Configuration

Add to VS Code settings.json:

Using uvx:

{
  "github.copilot.chat.mcp.servers": {
    "yandex-tracker": {
      "type": "stdio",
      "command": "uvx",
      "args": ["yandex-tracker-mcp@latest"],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

Using Docker:

{
  "github.copilot.chat.mcp.servers": {
    "yandex-tracker": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "TRACKER_TOKEN",
        "-e", "TRACKER_CLOUD_ORG_ID",
        "ghcr.io/aikts/yandex-tracker-mcp:latest"
      ],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

For other MCP-compatible clients, use the standard MCP server configuration format:

Using uvx:

{
  "mcpServers": {
    "yandex-tracker": {
      "command": "uvx",
      "args": ["yandex-tracker-mcp@latest"],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

Using Docker:

{
  "mcpServers": {
    "yandex-tracker": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "TRACKER_TOKEN",
        "-e", "TRACKER_CLOUD_ORG_ID",
        "ghcr.io/aikts/yandex-tracker-mcp:latest"
      ],
      "env": {
        "TRACKER_TOKEN": "your_tracker_token_here",
        "TRACKER_CLOUD_ORG_ID": "your_cloud_org_id_here"
      }
    }
  }
}

• queues_get_all: List all available Yandex Tracker queues

  • Parameters:
    • fields (optional): Fields to include in the response (e.g., ["key", "name"]). Helps optimize context window usage by selecting only needed fields. If not specified, returns all available fields.
    • page (optional): Page number to return. If not specified, retrieves all pages automatically.
    • per_page (optional): Number of items per page (default: 100)
  • Returns {values, hits, pages}. hits/pages are reported only for an explicit single page on a server without TRACKER_LIMIT_QUEUES, since the totals count queues the allow-list then hides
  • Respects TRACKER_LIMIT_QUEUES restrictions

• queue_get_tags: Get all tags for a specific queue

  • Parameters: queue_id (string, queue key like "SOMEPROJECT")
  • Returns list of available tags in the specified queue
  • Respects TRACKER_LIMIT_QUEUES restrictions

• queue_get_versions: Get all versions for a specific queue

  • Parameters: queue_id (string, queue key like "SOMEPROJECT")
  • Returns list of available versions in the specified queue with details like name, description, dates, and status
  • Respects TRACKER_LIMIT_QUEUES restrictions

• queue_create_version: Create a new version in a specific queue

  • Parameters:
    • queue_id (string, required): Queue key like "SOMEPROJECT"
    • name (string, required): Version name
    • description (string, optional): Version description
    • start_date (date, optional): Version start date in YYYY-MM-DD format
    • due_date (date, optional): Version due date in YYYY-MM-DD format
  • Returns the created version with details like name, description, dates, and status
  • Respects TRACKER_LIMIT_QUEUES restrictions

• queue_get_fields: Get fields for a specific queue

  • Parameters:
    • queue_id (string, required): Queue key like "SOMEPROJECT"
    • include_local_fields (boolean, optional, default: true): Whether to include queue-specific local fields
  • Returns list of global fields and optionally local (queue-specific) fields
  • Makes parallel requests to fetch both field types when include_local_fields is true
  • The schema.required property indicates whether a field is mandatory
  • Use this to find available and required fields before creating an issue with issue_create tool
  • Respects TRACKER_LIMIT_QUEUES restrictions

• queue_get_metadata: Get detailed metadata about a specific queue

  • Parameters:
    • queue_id (string, required): Queue key like "SOMEPROJECT"
    • expand (array of strings, optional): Fields to expand in the response. Available options: all, projects, components, versions, types, team, workflows, fields, issueTypesConfig
  • Returns queue information including name, description, default type/priority, and optionally expanded data
  • Use expand: ["issueTypesConfig"] to get available resolutions for each issue type (needed for issue_close tool)
  • Respects TRACKER_LIMIT_QUEUES restrictions

Projects, portfolios and goals are separate Yandex Tracker entities (distinct from queues) exposed through the Tracker "entities" API. Each entity type has its own dedicated tool and explicit schema; custom (organization-defined) attributes are not modeled and are not returned.

These tools are opt-in. They are registered only when TRACKER_ENTITIES_ENABLED=true (default false), because they add a large tool manifest and are not covered by the queue restrictions — see Queue Access Control.

• project_get: Get a project by its id or shortId

  • Parameters:
    • entity_id (string, required): Project id or shortId
    • fields (array of strings, optional): Entity fields to include, constrained to the allowed values for this entity type. Defaults to a base field set (summary, description, entityStatus, start, end, lead, author, tags; goals omit start, which the API does not define for them)
  • Returns project metadata (id, shortId, version, createdBy/createdAt/updatedAt) and the requested fields

• project_find: Search projects by name substring and/or field filters

  • Parameters (all optional): input (substring match), filter (field criteria map), order_by, order_asc, root_only (exclude nested entities), page, per_page, fields
  • Returns a paginated search result (hits, pages, values)

• portfolio_get / portfolio_find: Same shape as project_get / project_find, for portfolios (a portfolio groups projects and/or other portfolios)

• goal_get / goal_find: Same shape as project_get / project_find, for goals. Goals use a different entityStatus value set (draft, according_to_plan, at_risk, blocked, achieved, partially_achieved, not_achieved, exceeded, cancelled)

• project_get_comments: Get a page of comments of a project by its id or shortId

  • Parameters: entity_id (required); per_page (optional, default 50); cursor (optional, the next_cursor from the previous call); fields (optional, array of comment field names — text/text_html can be large, so select only what you need; omit to get all fields)
  • Returns {comments, next_cursor} (comments have the same shape as issue comments). Cursor-paginated: keep passing next_cursor back as cursor until it is null

• portfolio_get_comments / goal_get_comments: Same shape as project_get_comments, for portfolios and goals

Write tools (project_create/project_update/project_delete and the equivalent portfolio_* / goal_* tools) are also available and are only registered when TRACKER_ENTITIES_ENABLED is set and TRACKER_READ_ONLY is not:

• project_create: Create a project. Requires summary. Accepts description, lead, team_users, clients, followers, start, end, tags, entity_status, parent_entity, team_access, and links
• project_update: Update any of the above fields on an existing project. Accepts an optional comment and version (for optimistic-concurrency conflict detection). Passing links adds links, it does not replace them — re-sending an existing link fails. Links are write-only in the Tracker API (links is not a valid fields value and is not returned by get/update), so the current set cannot be read back and links cannot be removed through the server. Tracker also ignores a links-only update, so links must accompany a field change or a comment; the server rejects a links-only call instead of reporting a no-op as success (all verified against the live API)
• project_delete: Delete a project. Accepts an optional with_board flag to also delete the associated board
• portfolio_create / portfolio_update / portfolio_delete: Same shape as the project write tools
• goal_create / goal_update / goal_delete: Same shape as the portfolio write tools, without start, and using the goal entityStatus and link-relationship value sets. goal_delete has no with_board flag, since goals have no board

All create/update tools accept the same fields selector as the read tools and return the created/updated entity with those fields populated.

• project_add_comment: Add a comment to a project. Requires entity_id and text (Markdown/YFM supported). Accepts optional summonees (user logins/IDs to notify — use this instead of @login in the text) and maillist_summonees (mailing list emails)
• project_update_comment: Update an existing comment. Requires entity_id, comment_id, and text. Accepts the same optional summonees / maillist_summonees
• project_delete_comment: Delete a comment. Requires entity_id and comment_id
• portfolio_add_comment / portfolio_update_comment / portfolio_delete_comment and goal_add_comment / goal_update_comment / goal_delete_comment: Same shape as the project comment write tools, for portfolios and goals

Projects and portfolios (not goals — the Yandex Tracker API does not support checklists on goals) also expose checklist write tools. All of them return the full updated entity (request checklistItems via fields to see the current items):

• project_add_checklist_item: Add a checklist item. Requires entity_id and text. Accepts optional checked, assignee (user ID/login), and deadline (e.g. {'date': '2026-08-20T00:00:00.000+0000', 'deadlineType': 'date'})
• project_update_checklist_item: Partially update a checklist item. Requires entity_id and checklist_item_id; all other fields (text, checked, assignee, deadline) are optional and only change what's passed
• project_move_checklist_item: Reorder a checklist item. Requires entity_id, checklist_item_id, and before (the id of the item to insert immediately above)
• project_delete_checklist_item: Delete a single checklist item. Requires entity_id and checklist_item_id
• project_update_checklist: Edit one or more existing checklist items by id. Requires entity_id and items ({id, text, checked?, assignee?, deadline?} objects). Only the listed items change — the server fetches the current checklist and resends it unmodified for every item you don't mention, working around the API rejecting a partial item list with a 500 (verified against the live API). Use the add/delete item tools to change the set
• project_delete_checklist: Delete the entire checklist. Requires entity_id
• portfolio_add_checklist_item / portfolio_update_checklist_item / portfolio_move_checklist_item / portfolio_delete_checklist_item / portfolio_update_checklist / portfolio_delete_checklist: Same shape as the project checklist write tools, for portfolios

Metrics (metricItems, on all three entity types) and a goal's key results (keyResultItems) are readable through the fields selector — request them explicitly, they are not in the default field set. Writing them is not supported: the API reference doesn't define whether an update replaces or merges these collections.

Not yet supported: writing metrics/key results, and bulk changes — these are tracked for a future iteration.

• users_get_all: Get information about user accounts registered in the organization

  • Parameters:
    • per_page (optional): Number of users per page (default: 50)
    • page (optional): Page number to return (default: 1)
    • fields (array of strings, optional): Fields to include per user. Not specifying this returns all available fields
  • Returns {values, hits, pages}: the page of users plus how many users there are in total and how many pages that is
  • Includes user metadata such as external status, dismissal status, and notification preferences
  • The current page is the last one when page equals pages

• user_get: Get information about a specific user by login or UID

  • Parameters: user_id (string, user login like "john.doe" or UID like "12345")
  • Returns detailed user information including login, email, license status, and organizational details
  • Supports both user login names and numeric user IDs for flexible identification

• user_get_current: Get information about the current authenticated user

  • No parameters required
  • Returns detailed information about the user associated with the current authentication token
  • Includes login, email, display name, and organizational details for the authenticated user

• users_search: Search user based on login, email or real name (first or last name, or both)

  • Parameters: login_or_email_or_name (string, user login, email or real name to search for)
  • Returns either single user or multiple users if several match the query or an empty list if no users matched
  • Uses fuzzy matching for real names with a similarity threshold of 80%, returning at most the 3 best matches
  • Prioritizes exact matches for login and email over fuzzy name matches

• get_global_fields: Get all global fields available in Yandex Tracker
  • Returns complete list of global fields that can be used in issues
  • Includes field schema, type information, and configuration

• get_statuses: Get all available issue statuses

  • Returns complete list of issue statuses that can be assigned
  • Includes status IDs, names, and type information

• get_issue_types: Get all available issue types

  • Returns complete list of issue types for creating/updating issues
  • Includes type IDs, names, and configuration details

• get_priorities: Get all available issue priorities

  • Returns complete list of priorities that can be assigned to issues
  • Includes priority keys, names, and order information

• get_resolutions: Get all available issue resolutions

  • Returns complete list of resolutions that can be used when closing issues
  • Includes resolution keys, names, descriptions, and order information

• issue_templates_get_all: Get all issue templates configured in Yandex Tracker

  • Parameters:
    • queue (string, optional): Return only the templates usable in that queue - its own templates plus the ones bound to no queue
    • page (integer, optional): Page number, default is all pages
    • per_page (integer, optional): Items per page (default: 50)
  • Returns {values, hits, pages}; values holds the templates teams use for bugs, incidents and other recurring work
  • Includes template id, name, owning queue and the fieldTemplates values the template prefills

• issue_template_get: Get a single issue template by its id

  • Parameters:
    • template_id (string): Template identifier, as returned by issue_templates_get_all
  • Use this before issue_create so the new issue follows the team's current template instead of an invented structure

• comment_templates_get_all: Get all comment templates configured in Yandex Tracker

  • Parameters:
    • queue (string, optional): Return only the templates usable in that queue - its own templates plus the ones bound to no queue
    • page (integer, optional): Page number, default is all pages
    • per_page (integer, optional): Items per page (default: 50)
  • Returns {values, hits, pages}; values holds the wording teams reuse when replying on issues
  • Includes template id, name, description, owning queue, the template comment text and the summonees / maillistSummonees such a comment summons

• comment_template_get: Get a single comment template by its id

  • Parameters:
    • template_id (string): Template identifier, as returned by comment_templates_get_all
  • Use this before issue_add_comment so the comment follows the team's current template

Both listings paginate (the API returns 50 templates per page), so by default they walk every page and return the full set; pass page to fetch a single page when the context window is tight. As with queues_get_all, hits/pages are reported only for an explicit single page on a server without TRACKER_LIMIT_QUEUES: a full walk already returned everything there is, and the totals count templates the allow-list then hides.

Templates are read-only helpers: the Tracker API has no way to create an issue or a comment from a template, so issue_create and issue_add_comment take no template_id. Read the template first and pass its values as the tool's arguments.

All four tools respect TRACKER_LIMIT_QUEUES: templates bound to a restricted queue are omitted from the listings and rejected on direct access, while templates without a queue remain visible. Passing a restricted queue as queue is rejected as well.

• issue_get: Read one issue (task, ticket, bug) by its key/ID

  • Parameters:
    • issue_id (string, format: "QUEUE-123")
    • include_description (boolean, optional, default: true): Whether to include issue description in the result. Can be large, so use only when needed.
  • Returns the full issue record: summary, description, status, type, priority, assignee, author, tags, components, sprint, epic, parent, deadline, start date, story points, estimation, spent time, votes, created/updated timestamps and users, the current version, and any queue-local or custom fields
  • Call it right before issue_update to read a fresh version for optimistic locking; use issues_find when the key is unknown
  • Comments, links, attachments, worklogs, checklist, changelog and transitions are not part of the response - use the dedicated issue_get_* tools for those

• issue_get_url: Generate web URL for an issue

  • Parameters: issue_id (string)
  • Returns: https://tracker.yandex.ru/{issue_id}

• issue_get_comments: Fetch a page of comments for an issue

  • Parameters:
    • issue_id (string)
    • per_page (optional, default 50), cursor (optional, the next_cursor from the previous call)
    • fields (array of strings, optional): Fields to include per comment (text/text_html can be large). Not specifying this returns all available fields
  • Returns {comments, next_cursor} — comments in chronological order with metadata. Cursor-paginated: keep passing next_cursor back as cursor until it is null

• issue_add_comment: Add a comment to an issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123")
    • text (string, required): Comment text (markdown supported by Tracker)
    • summonees (array of strings, optional): Users to summon (logins or IDs). This is the API way to mention/call users (notifications are triggered by this field, not by @login in text).
    • maillist_summonees (array of strings, optional): Mailing lists to summon (emails)
    • markup_type (string, optional): Use md for YFM (markdown)
    • is_add_to_followers (boolean, optional, default: true): Add comment author to followers
  • Returns created comment object

• issue_update_comment: Update an existing comment in an issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123")
    • comment_id (int, required): Comment ID
    • text (string, required): New comment text (markdown supported by Tracker)
    • summonees (array of strings, optional): Users to summon (logins or IDs)
    • maillist_summonees (array of strings, optional): Mailing lists to summon (emails)
    • markup_type (string, optional): Use md for YFM (markdown)
  • Returns updated comment object

• issue_delete_comment: Delete a comment from an issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123")
    • comment_id (int, required): Comment ID
  • Returns: null (success)

• issue_add_link: Create a link between an issue and another issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123"): The current issue
    • relationship (string, required): Link type describing how issue_id relates to the linked issue. One of: relates, is dependent by, depends on, is subtask for, is parent task for, duplicates, is duplicated by, is epic of, has epic
    • issue (string, required): ID or key of the issue to link to (e.g. "TEST-123")
  • Returns created link object

• issue_delete_link: Delete a link between an issue and another issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123")
    • link_id (int, required): Link ID (as returned by issue_get_links)
  • Returns: null (success)

• issue_get_links: Get related issue links

  • Parameters: issue_id (string)
  • Returns links to related, blocked, or duplicate issues

• issue_get_worklogs: Retrieve worklog entries

  • Parameters:
    • issue_ids (array of strings)
    • fields (array of strings, optional): Fields to include per worklog entry. Not specifying this returns all available fields
  • Returns time tracking data for specified issues

• issue_add_worklog: Add a worklog entry (log spent time) to an issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123")
    • duration (string, required): ISO-8601 duration (e.g. PT1H30M)
    • comment (string, optional): Worklog comment
    • start (datetime, optional): Work start datetime (UTC assumed if timezone is not provided)
  • Returns created worklog entry

• issue_update_worklog: Update a worklog entry (spent time record) in an issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123")
    • worklog_id (int, required): Worklog entry ID
    • duration (string, optional): ISO-8601 duration (e.g. PT1H30M)
    • comment (string, optional): Worklog comment
    • start (datetime, optional): Work start datetime (UTC assumed if timezone is not provided)
  • Returns updated worklog entry

• issue_delete_worklog: Delete a worklog entry (spent time record) from an issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123")
    • worklog_id (int, required): Worklog entry ID
  • Returns: null (success)

• issue_get_attachments: Get attachments for an issue

  • Parameters:
    • issue_id (string, format: "QUEUE-123")
    • fields (array of strings, optional): Fields to include per attachment (the content field can be large). Not specifying this returns all available fields
  • Returns list of attachments with metadata for the specified issue

• issue_get_checklist: Get checklist items of an issue

  • Parameters: issue_id (string, format: "QUEUE-123")
  • Returns list of checklist items including text, status, assignee, and deadline information

• issue_get_transitions: Get possible status transitions for an issue

  • Parameters: issue_id (string, format: "QUEUE-123")
  • Returns list of available transitions that can be performed on the issue
  • Each transition includes an ID, display name, and target status information

• issue_get_changelog: Get the change history (changelog) of an issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123"): The issue key
    • per_page (integer, optional, default: 50): Number of entries per page
    • cursor (string, optional): The next_cursor value returned by the previous call; pass it to fetch the next page (cursor pagination)
    • field (string, optional): Filter the changelog by a field key (e.g. status)
    • type (string, optional): Filter by change type (e.g. IssueWorkflow for status transitions)
  • Returns an object with entries (status transitions and field edits — including who changed what from → to and when — plus comment changes and executed triggers) and next_cursor (pass it back as cursor for the next page; null when there are no more pages)

• issue_execute_transition: Execute a status transition for an issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123"): The issue key
    • transition_id (string, required): The transition ID to execute. IMPORTANT: Must be one of the IDs returned by issue_get_transitions tool
    • comment (string, optional): Optional comment to add when executing the transition
    • fields (object, optional): Dictionary of additional fields to set during the transition. Common fields include resolution (e.g., 'fixed', 'wontFix') for closing issues, assignee for reassigning, etc.
  • Returns list of available transitions for the new status after the transition is executed
  • Usage note: You MUST first call issue_get_transitions to retrieve available transitions, then pass one of the returned transition IDs. Do NOT use arbitrary transition IDs.

• issue_close: Close an issue with a resolution (convenience tool)

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123"): The issue key
    • resolution_id (string, required): The resolution ID to set when closing (e.g., 'fixed', 'wontFix', 'duplicate')
    • comment (string, optional): Optional comment to add when closing the issue
    • fields (object, optional): Dictionary of additional fields to set during the closing transition (e.g. assignee for reassigning). Do NOT set resolution here - use the dedicated resolution_id parameter instead
  • Automatically finds a transition to a 'done' status and executes it with the specified resolution
  • Returns list of available transitions for the new (closed) status
  • Usage note: Before closing, you MUST:
    1. Call issue_get to retrieve the issue's type field
    2. Call queue_get_metadata with expand: ["issueTypesConfig"] to get available resolutions
    3. Choose a resolution from the issueTypesConfig entry matching the issue's type - each issue type has its own set of valid resolutions

• issue_create: Create a new issue in a queue

  • Parameters:
    • queue (string, required): Queue key where to create the issue (e.g., 'MYQUEUE')
    • summary (string, required): Issue title/summary
    • type (IssueTypeRef or string or int, optional): Issue type with id and/or key, or the bare key/ID (from get_issue_types tool)
    • description (string, optional): Issue description (use markdown formatting)
    • markup_type (string, optional, default md): Markup type for description text (use 'md' for YFM markup)
    • assignee (string or int, optional): Assignee login or UID
    • priority (IssuePriorityRef or string or int, optional): Priority with id and/or key, or the bare key/ID (from get_priorities tool)
    • parent (IssueParentRef or string, optional): Parent issue reference with id and/or key (e.g., 'QUEUE-123'), or the bare key
    • sprint (array of IssueSprintRef, optional): Sprint assignments - array of objects with id (int) field
    • followers (array of IssueFollowerRef, optional): Followers - array of objects with id (user ID/uid or login)
    • components (array of IssueComponentRef, optional): Queue components - array of objects with either id (numeric component ID) or name (component name)
    • tags (array of strings, optional): Issue tags
    • project (IssueProjectRef, optional): Project with primary (int, main project shortId) and optional secondary (array of ints)
    • fields (object, optional): Additional fields without a dedicated parameter. IMPORTANT: Before creating an issue, you MUST call queue_get_fields to get available fields (it returns both global and local fields by default). Fields with schema.required=true are mandatory. Use the field's id property as the key in this map (e.g., {"fieldId": "value"}). Values are passed to Tracker as-is
  • Returns the newly created issue object with all standard issue fields
  • Accepts the same value formats as issue_update, so a reference value that works there works here too
  • Version note: the returned version can already be outdated - queue triggers and automation run right after creation and bump it. Do not feed it into a follow-up issue_update; re-read the issue with issue_get or omit version
  • Respects TRACKER_LIMIT_QUEUES restrictions

• issue_update: Update an existing issue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123"): The issue key to update
    • summary (string, optional): New issue title/summary
    • description (string, optional): New issue description
    • markup_type (string, optional): Markup type for description text (use 'md' for YFM markup)
    • parent (IssueParentRef or string, optional): Parent issue reference with id (string) and/or key (string, e.g., 'QUEUE-123'), or the bare key
    • sprint (array of IssueSprintRef, optional): Sprint assignments - array of objects with id (int) field
    • type (IssueTypeRef or string or int, optional): Issue type with id (string) and/or key (string, e.g., 'bug', 'task'), or the bare key/ID
    • priority (IssuePriorityRef or string or int, optional): Priority with id (string) and/or key (string, e.g., 'critical', 'normal'), or the bare key/ID
    • assignee (string or int, optional): New assignee login or UID
    • followers (array of IssueFollowerRef, optional): Followers - array of objects with id (user ID/uid or login); replaces the current list
    • components (array of IssueComponentRef, optional): Queue components - array of objects with either id (numeric component ID) or name (component name); replaces the current list
    • project (IssueProjectRef, optional): Project with primary (int, main project shortId) and optional secondary (array of ints)
    • tags (array of strings, optional): Issue tags
    • version (int, optional): Issue version for optimistic locking - changes are only applied when it is the issue's current version
    • fields (object, optional): Additional fields without a dedicated parameter. Use queue_get_fields to discover available fields. Values are passed to Tracker as-is
  • Returns the updated issue object with all standard issue fields
  • Only provided fields are updated; omitted fields remain unchanged
  • Version note: read version with issue_get immediately before updating, or omit it to update whatever the latest version is. A stale version fails with an editing conflict, which is easy to hit with the version returned by issue_create because queue triggers bump it
  • Respects TRACKER_LIMIT_QUEUES restrictions

• issue_move: Move an issue to a different queue

  • Parameters:
    • issue_id (string, required, format: "QUEUE-123"): The issue key to move
    • queue (string, required): Target queue key (e.g., 'MYQUEUE')
    • notify (boolean, optional, default true): Notify users referenced in the issue's fields
    • notify_author (boolean, optional, default false): Notify the issue author
    • move_all_fields (boolean, optional, default false): Carry over versions, components and projects when matching ones exist in the target queue; otherwise they are cleared
    • initial_status (boolean, optional, default false): Reset the issue status to the initial value (use when the target queue has a different workflow)
  • Returns the updated issue object with its new key in the target queue (e.g., TASKS-1 → NEWQUEUE-42)
  • When the MCP client supports elicitation, the user is prompted to confirm the boolean flags before the move is performed; declining or cancelling aborts the move. Clients without elicitation support proceed with the passed-in values
  • Respects TRACKER_LIMIT_QUEUES restrictions

• issues_find: Search issues using Yandex Tracker Query Language

  • Parameters:
    • query (required): Query string using Yandex Tracker Query Language syntax
    • include_description (boolean, optional, default: false): Whether to include issue description in the issues result. Can be large, so use only when needed. Ignored when description is listed in fields - naming it there is an explicit request for it.
    • fields (list of strings, optional): Fields to return, in Tracker's own spelling (storyPoints, not story_points). Any field name is accepted, including a queue's local and the organization's custom fields - pass the field id from queue_get_fields. A name Tracker does not know is dropped silently. If not specified, returns all available fields.
    • page (optional): Page number for pagination (default: 1)
    • per_page (optional): Number of items per page (default: 100). May be decreased if results exceed context window.
  • Returns {values, hits, pages}: the page of issues plus how many issues match in total and how many pages that is

• issues_count: Count issues matching a query using Yandex Tracker Query Language

  • Parameters:
    • query (required): Query string using Yandex Tracker Query Language syntax
  • Returns {"count": N} - the number of issues matching the specified criteria
  • Supports all query language features: field filtering, date functions, logical operators, and complex expressions
  • Useful for analytics, reporting, and understanding issue distribution without retrieving full issue data