Una implementación de servidor de Protocolo de contexto de modelo (MCP) que proporciona acceso a datos de JIRA con seguimiento de relaciones, cargas útiles de datos optimizadas y limpieza de datos para ventanas de contexto de IA.
ℹ️ Hay un servidor MCP separado para Confluence
Este servidor MCP admite instancias de Jira Cloud y Jira Server (Data Center) . Puede seleccionar el tipo de instancia configurando la variable de entorno JIRA_TYPE :
cloud (predeterminado): para Jira Cloud (alojado en Atlassian)
server : para Jira Server/Data Center (autoalojado)
El servidor utilizará automáticamente la versión de API y el método de autenticación correctos para el tipo seleccionado.
Related MCP server: MCP JIRA Server
Buscar problemas de JIRA usando JQL (máximo 50 resultados por solicitud)
Recupere hijos épicos con historial de comentarios y cargas útiles optimizadas (máximo 100 problemas por solicitud)
Obtenga información detallada del problema, incluidos comentarios y problemas relacionados
Crear, actualizar y gestionar problemas de JIRA
Añadir comentarios a los problemas
Extraer menciones de problemas del formato de documento Atlassian
Realizar un seguimiento de las relaciones entre problemas (menciones, enlaces, padre/hijo, epopeyas)
Limpie y transforme el contenido enriquecido de JIRA para lograr una mayor eficiencia en el contexto de IA
Soporte para archivos adjuntos con manejo seguro de carga de varias partes
Admite las API de Jira Cloud y Jira Server (Data Center)
Bun (v1.0.0 o superior)
Cuenta JIRA con acceso a la API
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 buildEdite el archivo de configuración apropiado:
macOS:
Cline: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Escritorio de Claude: ~/Library/Application Support/Claude/claude_desktop_config.json
Ventanas:
Cline: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
Escritorio de Claude: %APPDATA%\Claude Desktop\claude_desktop_config.json
Linux:
Cline: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Claude Desktop: lamentablemente aún no existe
Agregue la siguiente configuración bajo el objeto 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"
}
}
}
}En la configuración de MCP de Cline, reinicie el servidor MCP. Reinicie Claude Desktop para cargar el nuevo servidor MCP.
Ejecutar pruebas:
bun testModo de observación para el desarrollo:
bun run devPara reconstruir después de los cambios:
bun run buildBusca incidencias de JIRA con JQL. Devuelve hasta 50 resultados por solicitud.
Esquema de entrada:
{
searchString: string; // JQL search string
}Obtenga todos los problemas de los niños en una épica, incluyendo sus comentarios y datos de relación. Límite de 100 problemas por solicitud.
Esquema de entrada:
{
epicKey: string; // The key of the epic issue
}Obtenga información detallada sobre un problema específico de JIRA, incluidos comentarios y todas las relaciones.
Esquema de entrada:
{
issueId: string; // The ID or key of the JIRA issue
}Cree un nuevo problema de JIRA con campos específicos.
Esquema de entrada:
{
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
}
}Actualizar los campos de un problema de JIRA existente.
Esquema de entrada:
{
issueKey: string, // The key of the issue to update
fields: { // Fields to update
[key: string]: any
}
}Agregar un archivo adjunto a un problema de JIRA.
Esquema de entrada:
{
issueKey: string, // The key of the issue
fileContent: string, // Base64 encoded file content
filename: string // Name of the file to be attached
}Añade un comentario a una incidencia de JIRA. Acepta texto sin formato y lo convierte internamente al formato de documento Atlassian requerido.
Esquema de entrada:
{
issueIdOrKey: string, // The ID or key of the issue to add the comment to
body: string // The content of the comment (plain text)
}Extrae texto del formato de documento Atlassian
Los problemas de seguimiento se mencionan en descripciones y comentarios
Mantiene vínculos formales de problemas con tipos de relación
Preserva las relaciones entre padres e hijos
Rastrea asociaciones épicas
Incluye historial de comentarios con información del autor.
Elimina metadatos innecesarios de las respuestas
Procesa recursivamente nodos de contenido para menciones
Menciones de problemas de deduplicación
Construido con TypeScript en modo estricto
Utiliza el tiempo de ejecución de Bun para un mejor rendimiento
Vite para compilaciones optimizadas
Utiliza JIRA REST API v3
Autenticación básica con tokens API
Solicitudes de API por lotes para datos relacionados
Cargas útiles de respuesta optimizadas para ventanas de contexto de IA
Transformación eficiente de estructuras complejas de Atlassian
Manejo robusto de errores
Consideraciones sobre la limitación de velocidad
Límites máximos:
Resultados de la búsqueda: 50 números por solicitud
Niños épicos: 100 ejemplares por solicitud
Compatibilidad con datos de formularios multiparte para adjuntar archivos de forma segura
Detección y validación automática del tipo de contenido
El servidor implementa una estrategia integral de manejo de errores:
Detección de errores de red y mensajería adecuada
Manejo de códigos de estado HTTP (especialmente 404 para problemas)
Mensajes de error detallados con códigos de estado
Detalles del error al registrarse en la consola
Validación de entrada para todos los parámetros
Propagación segura de errores mediante el protocolo MCP
Manejo especializado de errores comunes de la API de JIRA
Validación Base64 para archivos adjuntos
Manejo de errores de solicitudes multiparte
Detección de límite de velocidad
Validación de parámetros de adjuntos
Este proyecto está licenciado bajo la licencia MIT: consulte el archivo de LICENCIA para obtener más detalles.
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.
