Provides tools for searching, creating, updating, and managing Jira issues, including support for epics, comments, attachments, and relationship tracking, compatible with both Jira Cloud and Jira Server/Data Center.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@JIRA MCP Server search for issues with label 'critical' in project TEST"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A fork on the original project on github.com/cosmix/jira-mcp to be transformed as a Kiro Powers
Related MCP server: Jira MCP Server
A Model Context Protocol (MCP) server implementation that provides access to JIRA data with relationship tracking, optimized data payloads, and data cleaning for AI context windows.
ℹ️ There is a separate MCP server for Confluence
This MCP server supports both Jira Cloud and Jira Server (Data Center) instances. You can select which type to use by setting the JIRA_TYPE environment variable:
cloud (default): For Jira Cloud (Atlassian-hosted)
server: For Jira Server/Data Center (self-hosted)
The server will automatically use the correct API version and authentication method for the selected type.
Search JIRA issues using JQL (maximum 50 results per request)
Retrieve epic children with comment history and optimized payloads (maximum 100 issues per request)
Get detailed issue information including comments and related issues
Create, update, and manage JIRA issues
Add comments to issues
Extract issue mentions from Atlassian Document Format
Track issue relationships (mentions, links, parent/child, epics)
Clean and transform rich JIRA content for AI context efficiency
Support for file attachments with secure multipart upload handling
Supports both Jira Cloud and Jira Server (Data Center) APIs
Bun (v1.0.0 or higher)
JIRA account with API access
JIRA_API_TOKEN=your_api_token # API token for Cloud, PAT or password for Server/DC
JIRA_BASE_URL=your_jira_instance_url # e.g., https://your-domain.atlassian.net
JIRA_USER_EMAIL=your_email # Your Jira account email
JIRA_TYPE=cloud # 'cloud' or 'server' (optional, defaults to 'cloud')
JIRA_AUTH_TYPE=basic # 'basic' or 'bearer' (optional, defaults to 'basic')Jira Cloud: Use API tokens with Basic authentication
Create an API token at: https://id.atlassian.com/manage-profile/security/api-tokens
Set JIRA_AUTH_TYPE=basic (default)
Jira Server/Data Center:
Basic Auth: Use username/password or API tokens
Set JIRA_AUTH_TYPE=basic (default)
Bearer Auth: Use Personal Access Tokens (PATs) - available in Data Center 8.14.0+
Create a PAT in your profile settings
Set JIRA_AUTH_TYPE=bearer
Use the PAT as your JIRA_API_TOKEN
git clone [repository-url]
cd jira-mcpbun install
bun run buildEdit the appropriate configuration file:
macOS:
Cline: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows:
Cline: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
Claude Desktop: %APPDATA%\Claude Desktop\claude_desktop_config.json
Linux:
Cline: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Claude Desktop: sadly doesn't exist yet
Add the following configuration under the mcpServers object:
{
"mcpServers": {
"jira": {
"command": "node",
"args": ["/absolute/path/to/jira-mcp/build/index.js"],
"env": {
"JIRA_API_TOKEN": "your_api_token",
"JIRA_BASE_URL": "your_jira_instance_url",
"JIRA_USER_EMAIL": "your_email",
"JIRA_TYPE": "cloud",
"JIRA_AUTH_TYPE": "basic"
}
}
}
}Within Cline's MCP settings, restart the MCP server. Restart Claude Desktop to load the new MCP server.
Run tests:
bun testWatch mode for development:
bun run devTo rebuild after changes:
bun run buildSearch JIRA issues using JQL. Returns up to 50 results per request.
Input Schema:
{
searchString: string; // JQL search string
}Get all child issues in an epic including their comments and relationship data. Limited to 100 issues per request.
Input Schema:
{
epicKey: string; // The key of the epic issue
}Get detailed information about a specific JIRA issue including comments and all relationships.
Input Schema:
{
issueId: string; // The ID or key of the JIRA issue
}Create a new JIRA issue with specified fields.
Input Schema:
{
projectKey: string, // The project key where the issue will be created
issueType: string, // The type of issue (e.g., "Bug", "Story", "Task")
summary: string, // The issue summary/title
description?: string, // Optional issue description
fields?: { // Optional additional fields
[key: string]: any
}
}Update fields of an existing JIRA issue.
Input Schema:
{
issueKey: string, // The key of the issue to update
fields: { // Fields to update
[key: string]: any
}
}Add a file attachment to a JIRA issue.
Input Schema:
{
issueKey: string, // The key of the issue
fileContent: string, // Base64 encoded file content
filename: string // Name of the file to be attached
}Add a comment to a JIRA issue. Accepts plain text and converts it to the required Atlassian Document Format internally.
Input Schema:
{
issueIdOrKey: string, // The ID or key of the issue to add the comment to
body: string // The content of the comment (plain text)
}Extracts text from Atlassian Document Format
Tracks issue mentions in descriptions and comments
Maintains formal issue links with relationship types
Preserves parent/child relationships
Tracks epic associations
Includes comment history with author information
Removes unnecessary metadata from responses
Recursively processes content nodes for mentions
Deduplicates issue mentions
Built with TypeScript in strict mode
Uses Bun runtime for improved performance
Vite for optimized builds
Uses JIRA REST API v3 (Cloud) or v2 (Server/Data Center)
Supports multiple authentication methods:
Basic authentication with API tokens or username/password
Bearer authentication with Personal Access Tokens (PATs)
Batched API requests for related data
Optimized response payloads for AI context windows
Efficient transformation of complex Atlassian structures
Robust error handling
Rate limiting considerations
Maximum limits:
Search results: 50 issues per request
Epic children: 100 issues per request
Support for multipart form data for secure file attachments
Automatic content type detection and validation
The server implements a comprehensive error handling strategy:
Network error detection and appropriate messaging
HTTP status code handling (especially 404 for issues)
Detailed error messages with status codes
Error details logging to console
Input validation for all parameters
Safe error propagation through MCP protocol
Specialized handling for common JIRA API errors
Base64 validation for attachments
Multipart request failure handling
Rate limit detection
Attachment parameter validation
This project is licensed under the MIT License - see the LICENCE file for details.
Add a file attachment to a JIRA issue
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | Name of the file to be attached | |
| issueKey | Yes | The key of the issue to add attachment to | |
| fileContent | Yes | Base64 encoded content of the file |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description does not disclose any behavioral traits beyond the basic action. It fails to mention important details like required permissions, file size limits, or whether the attachment replaces existing ones. The description carries the full burden but only states the action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that communicates the essential purpose without any unnecessary words. It is well-structured and immediately understandable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with three parameters and no output schema, the description is adequate but incomplete. It does not mention constraints like base64 encoding (though schema does), file size limits, or whether the tool returns anything. Given the simplicity, a 3 is fair.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with clear parameter descriptions (filename, issueKey, fileContent). The tool description does not add extra meaning beyond the schema, so a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: adding a file attachment to a JIRA issue. It uses a specific verb ('Add') and resource ('file attachment to a JIRA issue'), and distinguishes it from sibling tools like add_comment or create_issue.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. For example, it doesn't mention that attachments are only possible from a certain issue type or that there are size limits. The description is purely declarative without context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Add a comment to a JIRA issue
| Name | Required | Description | Default |
|---|---|---|---|
| body | Yes | The content of the comment (plain text) | |
| issueIdOrKey | Yes | The ID or key of the issue to add the comment to |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It does not disclose behavioral traits like whether the comment is appended, supports rich text, or requires specific permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no unnecessary words. Direct and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with two parameters, the description is adequate. No output schema, but the function is straightforward. Could mention if comment is appended or replaces.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and descriptions are clear. Description does not add additional meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add a comment') and the resource ('JIRA issue'), with a specific verb and resource. It distinguishes from siblings like add_attachment and create_issue.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, such as when to add attachment or update issue. No mention of prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new JIRA issue
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | Additional fields to set on the issue | |
| summary | Yes | The issue summary/title | |
| issueType | Yes | The type of issue to create (e.g., "Bug", "Story", "Task") | |
| projectKey | Yes | The project key where the issue will be created | |
| description | No | The issue description |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description lacks behavioral details beyond the fact that it creates. It does not mention permissions, side effects, return value, or any constraints, leaving the agent underinformed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, which is generally positive. However, given the tool's complexity (5 parameters, nested objects), it may benefit from slightly more detail without losing brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too sparse for a creation tool with no output schema. It fails to mention what the tool returns, any required permissions, or potential side effects, leaving significant gaps for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter information beyond what the schema already provides, so no increase is warranted.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Create a new JIRA issue', specifying a concrete action and resource. It distinguishes itself from sibling tools like update_issue, add_attachment, and search_issues.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for creating issues but provides no guidance on when not to use it or alternatives. The context of sibling tools is present but not explicitly addressed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all child issues in an epic including their comments
| Name | Required | Description | Default |
|---|---|---|---|
| epicKey | Yes | The key of the epic issue |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavior. It mentions returning child issues and comments, but omits details such as pagination, sorting, limits, error handling, or whether the result is a flat list or nested. This is insufficient for a retrieval tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no wasted words. However, it lacks structure such as bullets or examples that could improve readability. Still appropriate for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description should explain the return value more fully. It mentions comments but not that it returns a list of issue objects. Moderate completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (epicKey described). The description adds no additional meaning to the parameter beyond what the schema already provides. Baseline is 3 for full coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves child issues of an epic including their comments. It uses a specific verb (get) and resource (epic children). This distinguishes it from siblings like get_issue (single issue) and search_issues (search).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like search_issues. No prerequisites or context provided. The description only states what it does, without usage conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific JIRA issue including comments
| Name | Required | Description | Default |
|---|---|---|---|
| issueId | Yes | The ID or key of the JIRA issue |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, permissions, or response format, leaving the agent uninformed about side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence that is front-loaded with key action and resource, no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description adequately explains the purpose, though it could mention return format or data scope for full completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter, and the description adds no new meaning beyond the schema's description of issueId. Baseline 3 applies as per rules.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get detailed information about a specific JIRA issue including comments', specifying the verb, resource, and distinguishing it from sibling tools like get_epic_children or get_transitions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implied usage for retrieving detailed info for one issue, but no explicit guidance on when to use versus search_issues or alternatives, nor any when-not-to-use conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get available status transitions for a JIRA issue
| Name | Required | Description | Default |
|---|---|---|---|
| issueKey | Yes | The key of the issue to get transitions for |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description indicates a read operation ('get') but does not disclose any potential restrictions or side effects. Without annotations, more detail on authorization or result filtering would be helpful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no wasted words. Front-loaded with clear purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema present, and the description does not explain the return format (e.g., list of transition objects). While adequate for a simple tool, could be more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already fully describes the only parameter (issueKey). The description adds no additional semantic value beyond what is in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Get available status transitions for a JIRA issue' with specific verb and resource. Clearly distinguishes from sibling tools like transition_issue which applies a transition.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like transition_issue. Does not provide context for prerequisites or typical usage flow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search JIRA issues using JQL
| Name | Required | Description | Default |
|---|---|---|---|
| searchString | Yes | JQL search string |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states the basic action. It does not disclose important behavioral traits such as whether the operation is read-only, pagination behavior, error handling for invalid JQL, or any authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. Every word serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having only one parameter, the description lacks critical details such as result format, pagination, sorting, or limits. For a search tool, an agent needs to know these aspects to use it properly. The absence of an output schema amplifies this gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema is fully covered with a description for the single parameter searchString ('JQL search string'), so the description adds no additional meaning beyond the schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Search' and the resource 'JIRA issues using JQL', which is specific and immediately distinguishes this tool from siblings like get_issue (retrieve by ID) or create_issue (creation).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description only implies usage via JQL but provides no explicit guidance on when to use this tool versus alternatives (e.g., get_issue for specific issues, or other search tools). No when-not-to or exclusionary criteria are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Change the status of a JIRA issue by performing a transition
| Name | Required | Description | Default |
|---|---|---|---|
| comment | No | Optional comment to add with the transition | |
| issueKey | Yes | The key of the issue to transition | |
| transitionId | Yes | The ID of the transition to perform |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description only says 'change the status' with no details on side effects, permissions, or required knowledge of transition IDs. This is insufficient for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no redundancy, but too brief to be informative. Sacrifices clarity for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, no annotations, and no explanation of how to obtain transition IDs or what happens after transition. Incomplete for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions; the tool description adds no extra meaning beyond what the schema already provides. Baseline score applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the verb 'change' and resource 'status of a JIRA issue', but uses the jargon 'transition' which may not be clear to all users. It distinguishes from general 'update_issue' but could be more specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus siblings like 'get_transitions' or 'update_issue'. The agent must infer context from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update an existing JIRA issue
| Name | Required | Description | Default |
|---|---|---|---|
| fields | Yes | Fields to update on the issue | |
| issueKey | Yes | The key of the issue to update |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure. It only says 'Update an existing JIRA issue', lacking details on permissions, error handling, partial update semantics, or consequences of invalid issue keys.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no waste, but it is too minimal. Conciseness is achieved at the cost of completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of output schema and the presence of many sibling tools, the description is incomplete. It does not explain how to structure the fields object or handle partial updates.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Parameters have schema descriptions (100% coverage), so baseline is 3. The description does not add meaning beyond the schema; the 'fields' object description is generic and offers no guidance on expected properties or format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Update' and resource 'existing JIRA issue', distinguishing it from sibling tools like create_issue and transition_issue.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for modifying an existing issue but does not explicitly state when to use it versus alternatives like transition_issue for status changes or add_comment for comments. No when-not-to-use guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0add_attachmentadd_commentcreate_issueget_epic_childrenget_issueget_transitionssearch_issuestransition_issueupdate_issueScored across 9 tools
Each tool targets a distinct action: attachments, comments, creation, retrieval of issues/epics, transitions, search, and updates. There is no overlap in purpose, ensuring clear differentiation.
All tool names follow a consistent verb_noun pattern (e.g., add_attachment, get_issue, search_issues) using lowercase with underscores. No naming irregularities exist.
With 9 tools, the server covers essential JIRA operations—CRUD, comments, attachments, transitions, and search—without being bloated or sparse. The count is well-scoped for an issue management server.
The tool set covers core issue lifecycle (create, read, update, transition, search, comment, attach) but lacks a delete tool. However, JIRA often relies on transitions rather than deletion, so the gap is minor.
Connect to Atlassian Jira, Confluence, Loom, and more to search, create, and manage your work.
Task manager your agent can fully operate: boards, tasks, sprints, roles, worklogs, day planner.
Manage dillie projects, tasks, and sprints; look up members and search platform documentation.
Search, read and create Linear issues, projects, teams and cycles.