リレーションシップ追跡、最適化されたデータ ペイロード、AI コンテキスト ウィンドウのデータ クリーニングを備えた JIRA データへのアクセスを提供するモデル コンテキスト プロトコル (MCP) サーバー実装。
ℹ️ Confluence には別の MCP サーバーがあります
このMCPサーバーは**、Jira CloudとJira Server（Data Center）の**両方のインスタンスをサポートしています。JIRA_TYPE環境変数JIRA_TYPE設定することで、使用するタイプを選択できます。
cloud （デフォルト）：Jira Cloud（Atlassianホスト）の場合
server : Jira Server/Data Center (セルフホスト)
サーバーは、選択したタイプに対して適切な API バージョンと認証方法を自動的に使用します。
Related MCP server: MCP JIRA Server
JQL を使用して JIRA の問題を検索する (リクエストごとに最大 50 件の結果)
コメント履歴と最適化されたペイロードを含むエピックの子を取得します（リクエストごとに最大 100 件の問題）
コメントや関連する問題を含む詳細な問題情報を取得します
JIRA の問題を作成、更新、管理する
問題にコメントを追加する
Atlassian ドキュメント形式から問題の言及を抽出する
問題の関係性を追跡する（メンション、リンク、親子、エピック）
AI コンテキストの効率化のために、豊富な JIRA コンテンツをクリーンアップして変換します
安全なマルチパートアップロード処理によるファイル添付のサポート
Jira Cloud と Jira Server (データセンター) API の両方をサポート
Bun （v1.0.0以上）
APIアクセス可能なJIRAアカウント
JIRA_API_TOKEN=your_api_token
JIRA_BASE_URL=your_jira_instance_url # e.g., https://your-domain.atlassian.net
JIRA_USER_EMAIL=your_email
JIRA_TYPE=cloud # or 'server' for Jira Server/Data Center (optional, defaults to 'cloud')git clone [repository-url]
cd jira-mcpbun install
bun run build適切な構成ファイルを編集します。
macOS:
Cline: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Claude デスクトップ: ~/Library/Application Support/Claude/claude_desktop_config.json
ウィンドウズ:
クライン: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
クロード デスクトップ: %APPDATA%\Claude Desktop\claude_desktop_config.json
リナックス:
クライン: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Claude Desktop:残念ながらまだ存在しません
mcpServersオブジェクトの下に次の構成を追加します。
{
"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"
}
}
}
}ClineのMCP設定で、MCPサーバーを再起動します。Claude Desktopを再起動して、新しいMCPサーバーをロードします。
テストを実行します:
bun test開発のためのウォッチモード:
bun run dev変更後に再構築するには:
bun run buildJQL を使用して JIRA の問題を検索します。リクエストごとに最大 50 件の結果が返されます。
入力スキーマ:
{
searchString: string; // JQL search string
}エピック内のすべての子課題を、コメントと関係データを含めて取得します。1回のリクエストあたり100件までに制限されます。
入力スキーマ:
{
epicKey: string; // The key of the epic issue
}コメントやすべての関係など、特定の JIRA 問題に関する詳細情報を取得します。
入力スキーマ:
{
issueId: string; // The ID or key of the JIRA issue
}指定されたフィールドで新しい JIRA 問題を作成します。
入力スキーマ:
{
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
}
}既存の JIRA 課題のフィールドを更新します。
入力スキーマ:
{
issueKey: string, // The key of the issue to update
fields: { // Fields to update
[key: string]: any
}
}JIRA の問題にファイル添付ファイルを追加します。
入力スキーマ:
{
issueKey: string, // The key of the issue
fileContent: string, // Base64 encoded file content
filename: string // Name of the file to be attached
}JIRA の課題にコメントを追加します。プレーンテキストを受け付け、内部で必要な Atlassian ドキュメント形式に変換します。
入力スキーマ:
{
issueIdOrKey: string, // The ID or key of the issue to add the comment to
body: string // The content of the comment (plain text)
}Atlassianドキュメントフォーマットからテキストを抽出します
説明とコメントで問題に関する言及を追跡します
関係タイプによる正式な問題リンクを維持する
親子関係を維持する
壮大なつながりを追跡
著者情報を含むコメント履歴が含まれます
レスポンスから不要なメタデータを削除します
言及のコンテンツノードを再帰的に処理する
問題に関する言及を重複排除
TypeScript の厳密モードで構築
パフォーマンス向上のため、Bun ランタイムを使用
最適化されたビルドのためのVite
JIRA REST API v3 を使用
APIトークンを使用した基本認証
関連データに対するバッチAPIリクエスト
AIコンテキストウィンドウに最適化された応答ペイロード
複雑なアトラシアン構造の効率的な変換
堅牢なエラー処理
レート制限に関する考慮事項
最大制限:
検索結果: 1リクエストあたり50件
エピックチルドレン：リクエストごとに100件
安全なファイル添付のためのマルチパートフォームデータのサポート
コンテンツタイプの自動検出と検証
サーバーは包括的なエラー処理戦略を実装します。
ネットワークエラーの検出と適切なメッセージング
HTTP ステータス コードの処理 (特に問題の場合は 404)
ステータスコード付きの詳細なエラーメッセージ
エラーの詳細がコンソールに記録される
すべてのパラメータの入力検証
MCPプロトコルによる安全なエラー伝播
一般的な JIRA API エラーに対する特別な処理
添付ファイルのBase64検証
マルチパートリクエストの失敗処理
レート制限検出
添付ファイルパラメータの検証
このプロジェクトは MIT ライセンスに基づいてライセンスされています - 詳細についてはLICENCEファイルを参照してください。
Add a file attachment to a JIRA issue
| Name | Required | Description | Default |
|---|---|---|---|
| issueKey | Yes | The key of the issue to add attachment to | |
| fileContent | Yes | Base64 encoded content of the file | |
| filename | Yes | Name of the file to be attached |
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 |
|---|---|---|---|
| issueIdOrKey | Yes | The ID or key of the issue to add the comment to | |
| body | Yes | The content of the comment (plain text) |
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 |
|---|---|---|---|
| projectKey | Yes | The project key where the issue will be created | |
| issueType | Yes | The type of issue to create (e.g., "Bug", "Story", "Task") | |
| summary | Yes | The issue summary/title | |
| description | No | The issue description | |
| fields | No | Additional fields to set on the issue |
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 |
|---|---|---|---|
| issueKey | Yes | The key of the issue to transition | |
| transitionId | Yes | The ID of the transition to perform | |
| comment | No | Optional comment to add with the transition |
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 |
|---|---|---|---|
| issueKey | Yes | The key of the issue to update | |
| fields | Yes | Fields to update on the issue |
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 has a clearly distinct purpose targeting specific JIRA operations: create, get, update, search, transition, add attachments/comments, and get epic children. There is no overlap or ambiguity between tools like 'get_issue' and 'search_issues' or 'update_issue' and 'transition_issue', making misselection unlikely.
All tools follow a consistent verb_noun naming pattern with snake_case throughout (e.g., create_issue, get_issue, update_issue). The verbs are appropriate and predictable, with no mixing of conventions or styles, ensuring readability and coherence.
With 9 tools, the server is well-scoped for JIRA operations, covering core workflows like issue management, searching, and status transitions. Each tool earns its place without being overly sparse or bloated, fitting typical server sizes of 3-15 tools.
The tool set provides strong coverage for JIRA issue lifecycle, including CRUD operations (create, get, update), searching, transitions, and attachments/comments. A minor gap exists with no delete_issue tool, but agents can work around this, and other operations like epic handling are partially covered.
Intelligent context infrastructure for AI teams: knowledge graph, sessions, tasks, documents.
Issue tracking for software projects: issues, epics, releases, docs and boards, from your AI.
Track issues, projects and dependencies with your agent in a workspace you control.
Individual-analyst context layer: recall, remember, and reconcile your data and engineering context.
