Atlassian Jira Orchestrator Agent (MCP)

Leverage natural language processing to query and manipulate your Jira ecosystem. When paired with Claude Desktop and a project-specific context payload (defined in a custom README/context file), this server facilitates delegation of complex Project Management duties. For instance, it can intelligently route new tickets based on defined team expertise maps.

This module adheres strictly to the Model Context Protocol.

Core capabilities include:

• Project scaffolding and parameter definition.
• Comprehensive issue and subtask lifecycle management.
• Establishing relational dependencies between issues (linking).
• Orchestration of automated governance routines/workflows.

Configuration Directives

Mandatory runtime environmental variables:

• JIRA_HOST: The fully qualified domain name for your Jira installation.
• JIRA_API_TOKEN: A valid API credential acquired from https://id.atlassian.com/manage-profile/security/api-tokens OR a Personal Access Token (PAT).
• JIRA_AUTH_TYPE: Specifies the credential mechanism; use "basic" (the default) or "bearer".

Optional runtime environmental variables:

• JIRA_API_VERSION: The specific Jira API version endpoint to target (default value is "3").

Basic Authentication Mode (Default): - JIRA_EMAIL: Required for basic authentication, representing your Jira login email.

Personal Access Token (PAT) Authentication Mode: - Set JIRA_AUTH_TYPE=bearer and supply the generated PAT to JIRA_API_TOKEN. - JIRA_EMAIL is disregarded when utilizing PAT.

PAT Credential Acquisition Guidance

PATs are the favored, more secure method for interacting with Jira Cloud instances.

1. Navigate to your primary Jira portal settings.
2. Locate the Personal Access Tokens section (often under Security or Account Administration).
3. Initiate token generation by selecting Create token.
4. Assign a clear, descriptive label (e.g., "Production Orchestrator Access").
5. Verify that the assigned scopes grant necessary read/write access across projects and issues.
6. Safely capture the generated token as your JIRA_API_TOKEN.
7. Configure the environment by setting JIRA_AUTH_TYPE=bearer.

Caveat: If your specific Jira tenancy does not permit PAT generation, revert to the basic authentication schema utilizing a standard API token.

Exposed Operational Toolset

1. User Identity Retrieval

typescript // Resolve a user's internal account identifier using their electronic mail address { email: "target.user@organization.com"; }

2. Issue Schema Cataloging

typescript // Retrieve the complete repertoire of available issue classification definitions // Output structure includes: internal ID, canonical name, descriptive text, and subtask status flag. // Zero input parameters necessary.

3. Issue Relationship Schemas

typescript // Enumerate all predefined issue linkage types supported by the instance. // Returns: unique ID, standardized name, and directional descriptors (inward/outward). // Zero input parameters necessary.

4. Core Issue Manipulation

Data Retrieval

typescript // Fetch all recorded issues within a specified project container { projectKey: "PROJCODE" }

// Retrieve issues filtered via a custom JQL statement { projectKey: "PROJCODE", jql: "resolution IS EMPTY AND priority = Highest ORDER BY created ASC" }

// Obtain all tickets assigned to a specific entity { projectKey: "PROJCODE", jql: "assignee = \"email@corp.com\"" }

Item Generation

typescript // Construct a standard issue artifact { projectKey: "PROJCODE", summary: "Refactor Authentication Layer", issueType: "Improvement", description: "Migrate from legacy token system to OAuth 2.0 flows.", assignee: "internal_account_id_xyz", // Must be resolved via user_lookup tool labels: ["security", "backend"], components: ["auth_service"], priority: "Highest" }

// Generate a subordinate task { parent: "PROJCODE-456", projectKey: "PROJCODE", summary: "Write integration test cases for new endpoint", issueType: "Subtask", description: "Cover all edge cases for data validation.", assignee: "internal_account_id_abc" }

Record Modification

typescript // Alter defined attributes of an existing ticket { issueKey: "PROJCODE-123", summary: "Revised Scope: Database Connection Pooling", description: "Focus now strictly on optimizing connection overhead.", assignee: "new_user_id", status: "In Review", priority: "Medium" }

Dependency Structuring

typescript // Formalize a dependency link between two items { linkType: "Relates", // Use type name from list_link_types output inwardIssueKey: "PROJCODE-789", // The issue that is dependent on the outward issue outwardIssueKey: "PROJCODE-790" // The issue that is depended upon }

Item Removal

typescript // Erase a single issue artifact { issueKey: "PROJCODE-123" }

// Remove an issue along with all its directly attached children tasks { issueKey: "PROJCODE-123", deleteSubtasks: true }

// Bulk removal operation { issueKeys: ["PROJCODE-123", "PROJCODE-124", "PROJCODE-125"] }

Data Presentation Standards (Description Field)

The description parameter accepts text formatted similarly to Markdown:

• Separate distinct blocks of text using empty lines.
• Use the hyphen prefix (-) for unordered list items.
• Use sequential numbering (1.) for ordered sequences.
• Section headings should terminate with a colon (:), followed by a necessary blank line.

Example Format:

Project Mandate:

This phase targets deployment readiness across all services: - Service Alpha stabilization - Service Beta performance tuning

Implementation Phases: 1. Finalize API contracts. 2. Execute performance benchmarks. 3. Conduct security audit.

Go/No-Go Criteria: - Zero critical or high vulnerabilities identified. - Latency targets met under peak load.

Exception Management

The server is engineered to return explicit diagnostic feedback concerning:

• Non-existent issue identifiers.
• Omissions in required configuration parameters.
• Authorization failure codes.
• Exceeded rate limits imposed by the Jira service endpoint.

Deployment Protocol

Stage 1: Source Acquisition

bash git clone https://github.com/George5562/Jira-MCP-Server.git cd Jira-MCP-Server

Stage 2: Dependency Resolution

bash npm install

Stage 3: Credential Definition

Populate a local .env file at the root:

For Basic Authentication (Default): bash JIRA_HOST=your-domain.atlassian.net JIRA_EMAIL=your.identity@corp.com JIRA_API_TOKEN=YOUR_LEGACY_TOKEN JIRA_AUTH_TYPE=basic

For Personal Access Token (PAT) Auth: bash JIRA_HOST=your-domain.atlassian.net JIRA_API_TOKEN=YOUR_PAT_CREDENTIAL JIRA_AUTH_TYPE=bearer

Stage 4: Compilation

bash npm run build

Stage 5: Initialization

bash npm start

Client Integration Configuration

Integrating with Claude Desktop

To establish connectivity with Claude Desktop, modify its configuration file:

• macOS Location: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows Location: %APPDATA%/Claude/claude_desktop_config.json
• Linux Location: ~/.config/Claude/claude_desktop_config.json

Inject the Jira Orchestrator definition into the mcpServers object:

Configuration Snippet (Basic Auth Example):

{ "mcpServers": { "jira-orchestrator": { "name": "jira-orchestrator", "command": "/absolute/path/to/node", "args": ["/absolute/path/to/Jira-MCP-Server/build/index.js"], "cwd": "/absolute/path/to/Jira-MCP-Server", "env": { "JIRA_HOST": "your-instance.atlassian.net", "JIRA_EMAIL": "your-email@example.com", "JIRA_API_TOKEN": "your-api-token", "JIRA_AUTH_TYPE": "basic" } } } }

Configuration Snippet (PAT Auth Example):

{ "mcpServers": { "jira-orchestrator": { "name": "jira-orchestrator", "command": "/absolute/path/to/node", "args": ["/absolute/path/to/Jira-MCP-Server/build/index.js"], "cwd": "/absolute/path/to/Jira-MCP-Server", "env": { "JIRA_HOST": "your-instance.atlassian.net", "JIRA_API_TOKEN": "your-personal-access-token", "JIRA_AUTH_TYPE": "bearer" } } } }

Crucial Step: Ensure that /absolute/path/to/node points definitively to your Node.js binary (use which node to verify) and that paths reference the compiled server output (build/index.js). Restart Claude Desktop post-modification.

Integrating with Cursor (Project/Global MCP Configuration)

1. Ensure the server artifact is compiled: Execute npm run build within the repository folder.
2. Identify the configuration scope: Project-level (.cursor/mcp.json) or Global (~/.cursor/mcp.json).

3. Insert the server definition:

   Cursor Configuration (PAT Example):

   { "mcpServers": { "jira-system-interface": { "command": "node", "args": [ "/absolute/path/to/your/Jira-MCP-Server/build/index.js" ], "cwd": "/absolute/path/to/your/Jira-MCP-Server", "env": { "JIRA_HOST": "your-jira-instance.atlassian.net", "JIRA_API_TOKEN": "your-personal-access-token", "JIRA_AUTH_TYPE": "bearer" } } } }

   Substitute the placeholder absolute paths and ensure environment variables match your setup. Cursor must be restarted for new server definitions to take effect.

Contextual Anchoring via Cursor Rules

For frictionless interaction, establish default context parameters within Cursor's Rules mechanism (consult Cursor documentation for precise rule file location, typically .cursor/rules.json):

As an AI assistant managing Jira operations: - Default Project Context: Use 'CORE_PROJECT_REF' as the primary key. - Default User Identity: Resolve requests for 'myself' or 'my tasks' to Jira user: 'primary.agent@domain.com'. This allows simplified JQL queries like: project = CORE_PROJECT_REF AND assignee = primary.agent@domain.com.

Replace CORE_PROJECT_REF and the email placeholder with your genuine organizational identifiers.

Sample Conversational Query in Cursor

Once configured (especially with contextual rules):

"Jira Orchestrator: Fetch all outstanding bugs assigned to the QA team in the staging project. Then, generate a brief summary report detailing the resolution timelines based on current assignee workload."

Cursor will interface with the MCP agent to retrieve data and then execute the subsequent analytical and reporting steps.

Installation via Smithery Registry

Automate Claude Desktop configuration using the Smithery CLI:

bash npx -y @smithery/cli install @George5562/Jira-MCP-Server --client claude

Conceptual Context

WIKIPEDIA REFERENCE: Cloud computing, as defined by ISO, represents "a paradigm for enabling network access to a scalable and elastic pool of shareable physical or virtual resources with self-service provisioning and administration on-demand." This concept is colloquially known as "the cloud."

NIST Essential Attributes (2011):

1. On-demand self-service: Consumers provision capabilities (e.g., compute cycles, storage) autonomously, without provider staff intervention.
2. Broad network access: Availability across standard network protocols, accessible via diverse client apparatus (mobiles, workstations).
3. Resource pooling: Provider resources are shared via a multi-tenant structure, dynamically allocated based on shifting user demands.
4. Rapid elasticity: Capabilities can scale up or down swiftly, often automatically, appearing boundless to the end user.
5. Measured service: Resource consumption (storage, bandwidth, processing) is metered, ensuring transparent accounting for both supplier and consumer.

Further Documentation

• Model Context Protocol Specification
• Jira REST API Documentation
• Jira REST API Operational Examples