Jira MCP Server

The Jira MCP server connects AI agents to Atlassian Jira through the Model Context Protocol, exposing tools for searching issues, reading ticket details, creating and updating issues, transitioning statuses, and adding comments. The most credible community implementation is sooperset/mcp-atlassian, a Python server covering both Jira and Confluence. Authentication supports both Jira Cloud (via API token) and Jira Server/Data Center (via Personal Access Token).

Jira is where project work lives for most engineering teams, which also makes it one of the most annoying systems to interact with conversationally. The Jira MCP server fixes the friction: instead of navigating the Jira UI to look up a ticket, check status, or update a field, the agent can do it directly. You describe what you want in plain language, and the agent handles the API calls.

I've found this most useful for the routine tasks that feel too small to be worth the context switch but add up to real time lost: looking up ticket details while writing code, checking the status of a dependency, or quickly creating a bug report without leaving the editor.

What the server exposes

The Jira MCP server maps the Jira REST API to a set of agent-callable tools. The functional surface covers the main operations you'd actually use day-to-day.

Search issues runs a JQL query and returns matching issues with their key, summary, status, assignee, and priority. JQL (Jira Query Language) is the filter system built into Jira, and the agent can construct queries from plain-language descriptions. A request like "find all open bugs assigned to me in the BACKEND project" becomes project = BACKEND AND issuetype = Bug AND status != Done AND assignee = currentUser(). The server runs the JQL and returns the results.

Get issue fetches the full details of a specific ticket by key. You get the description, all comments, the changelog, linked issues, and field values. The agent uses this when it needs to understand the full context of an issue rather than just the summary.

Create issue creates a new ticket. At minimum you supply the project key, issue type, and summary. You can also set description, priority, assignee, labels, components, and (depending on the project's field configuration) custom fields. This is the tool that makes bug reporting and task creation genuinely faster.

Update issue modifies fields on an existing ticket. You pass the issue key and the fields to change. The agent can update assignees, priorities, labels, or descriptions without requiring a human to open the Jira UI.

Transition issue moves a ticket through its workflow. Jira workflows are configurable per project, so the agent first lists the available transitions for an issue (each has an ID and a name like "Start Progress" or "Done"), then calls the transition with the appropriate ID. This is how the agent marks tickets in-progress or closes them out.

Add comment posts a comment to an issue. Useful for having the agent log what it did, why a decision was made, or add context to a ticket it just updated.

List projects returns the projects visible to the authenticated account. Useful when the agent needs to look up project keys before constructing JQL.

Get issue types lists the issue types available in a project. Needed for create_issue calls where the type name matters.

Authentication setup

The mcp-atlassian server supports two auth modes: Jira Cloud via API token, and Jira Server/Data Center via Personal Access Token.

For Jira Cloud:

Generate an API token at id.atlassian.com/manage-profile/security/api-tokens. You need to be logged in to your Atlassian account. Copy the token; it is only shown once.

Set three environment variables:

• JIRA_URL: Your Jira Cloud URL, e.g., https://yourcompany.atlassian.net
• JIRA_USERNAME: The email address for your Atlassian account
• JIRA_API_TOKEN: The token you just copied

For Jira Server / Data Center:

Create a Personal Access Token in your Jira profile under "Personal Access Tokens". Then set:

• JIRA_URL: Your Jira Server URL, e.g., https://jira.yourcompany.com
• JIRA_PERSONAL_TOKEN: The PAT
• JIRA_AUTH_TYPE: pat

Installation and config

The server is Python-based and available through uvx for zero-install use:

uvx mcp-atlassian --jira-url https://yourcompany.atlassian.net \
  --jira-username [email protected] \
  --jira-api-token your-token-here

This tests the connection without writing anything to disk. If it prints the server startup output, your credentials are correct.

For Claude Desktop, add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "jira": {
      "command": "uvx",
      "args": ["mcp-atlassian"],
      "env": {
        "JIRA_URL": "https://yourcompany.atlassian.net",
        "JIRA_USERNAME": "[email protected]",
        "JIRA_API_TOKEN": "your-api-token"
      }
    }
  }
}

For Claude Code, the same block goes into ~/.claude/mcp.json. If you also want Confluence, add the corresponding Confluence env vars to the same server entry; the package handles both through the same process.

The uvx approach pulls the package on first run and caches it. Subsequent runs use the cache, so startup is fast after the first invocation.

Real use cases

Sprint planning support. An agent can search for all unassigned tickets in the backlog, group them by component, and suggest a sprint allocation based on story points and capacity. The agent reads the data; a human makes the decisions. The value is having organized information without the manual JQL queries and spreadsheet work.

Bug triage. New bugs come in with inconsistent detail. An agent equipped with the Jira server can read a new bug report, search for similar existing issues to check for duplicates, and draft a comment asking for missing reproduction steps. For teams getting a steady stream of inbound bugs, this is a meaningful time saver.

Status updates. Ask the agent to find all issues that were transitioned to "Done" in the last week, group them by assignee, and draft a summary for the weekly update. The JQL for this is straightforward and the agent handles the write-up.

Cross-referencing with code. Combined with GitHub MCP, an agent can look up a Jira ticket, find the corresponding PR in GitHub, and check whether the code actually addresses what the ticket describes. This kind of verification is the kind of thing that slips in manual review and an agent can do in seconds.

Automatic ticket creation from findings. An agent reviewing code with Filesystem MCP or GitHub can detect a pattern that should be tracked as a task, create the Jira ticket with appropriate fields, and link it to the relevant code. The loop between "found a problem" and "tracked a problem" closes without a human switching tools.

Release notes generation. Query all issues resolved in a version or sprint, read their summaries and descriptions, and generate a changelog draft. The agent can organize by issue type (bugs vs. features vs. improvements) and write the prose. It still needs human review, but starting from raw Jira data is more accurate than starting from memory.

JQL: the key to useful searches

JQL is what makes Jira search powerful, and the agent's ability to construct JQL from natural language is what makes Jira MCP practically useful. A few JQL patterns worth knowing:

# All open bugs in a project assigned to the current user
project = BACKEND AND issuetype = Bug AND status != Done AND assignee = currentUser()

# Issues updated in the last 7 days in an active sprint
project = BACKEND AND sprint in openSprints() AND updated >= -7d

# High-priority unassigned issues
project = BACKEND AND priority in (Highest, High) AND assignee is EMPTY

# Issues linked to a specific epic
"Epic Link" = BACKEND-123

# Recently created issues without a description
project = BACKEND AND created >= -1d AND description is EMPTY

You can describe these conditions to the agent in plain English and it will construct the JQL. The agent also handles JQL syntax errors by adjusting the query, which is useful when a field name or value does not exactly match what Jira expects.

Security considerations

The API token you configure inherits the full permissions of your Atlassian account. For most users, that means the agent can read and modify any issue in any project the account has access to.

Use a service account for team deployments. If you're setting this up for a shared workflow rather than personal use, create a dedicated Atlassian account with project-scoped permissions. Grant Browse Projects on the relevant projects, and only add Create Issues and Edit Issues if those tools are actually needed.

Rotate tokens periodically. Atlassian API tokens do not expire by default, but you can revoke them at any time from the token management page. Consider rotating the token if the machine it's configured on changes hands or if you no longer need the integration.

Do not put tokens in version control. The JIRA_API_TOKEN value in your MCP config file is sensitive. Keep config files in home directories rather than project directories to reduce the chance of accidental commit.

Be specific in transition prompts. The transition tool changes ticket status without a confirmation step. An agent asked to "clean up the backlog" might transition things you did not intend. Be explicit about which tickets should be transitioned and to what status.

Audit access for regulated environments. If your Jira instance holds customer PII, security vulnerabilities, or other sensitive information, audit which agent is being connected and what instructions it operates under before enabling this integration in that environment.

The official Atlassian picture

Atlassian announced MCP integrations in 2025 and is actively building out AI features across its product suite. The first-party path may look different by late 2026, and checking Atlassian's developer documentation at that point is worth doing before starting a new setup.

The sooperset/mcp-atlassian community server is the practical choice for 2026. It has seen consistent updates, handles both Cloud and Server deployments, covers Confluence alongside Jira, and the Python implementation is easy to inspect and modify if you need custom behavior.

Pairing with other servers

Jira MCP makes the most sense alongside servers that represent where the actual work happens. The most natural pairings:

GitHub MCP for linking tickets to code. An agent can move between a Jira issue and the GitHub PR that resolves it without you switching tabs.

Slack MCP for communication context. A ticket often has a parallel Slack thread where the real discussion happened. An agent with both can surface that context alongside the ticket.

Linear MCP is worth knowing about as an alternative. Linear is a competing project tracker that has a native MCP integration and a cleaner API than Jira's. If your team is not already on Jira and has a choice, Linear's MCP setup is simpler.

Bottom line

The Jira MCP server is most valuable for teams where Jira is genuinely central to how work gets organized. If your team lives in Jira, the constant tab-switching between your development tools and the browser is real friction, and this server removes most of it.

The read side is where it shines: searching issues, reading details, and generating summaries from JQL queries. The write side (creating tickets, updating fields, transitioning statuses) is powerful but deserves careful prompting and a service account with scoped permissions rather than connecting with an admin credential.

The setup with uvx takes about 10 minutes assuming you already have your Jira API token. After that, the tools are available in every session and the agent can work with your Jira data as naturally as any other context source.

Features

• Search issues using JQL (Jira Query Language)
• Read full issue details including description, comments, and attachments metadata
• Create new issues with type, summary, description, and custom fields
• Update existing issues (summary, description, priority, assignee, labels)
• Transition issues through workflow statuses
• Add comments to issues
• List projects and issue types
• Works with Jira Cloud and Jira Server/Data Center
• API token auth for Cloud, PAT auth for Server

How to set up the Jira MCP Server MCP server

1. Generate a Jira API token at id.atlassian.com/manage-profile/security/api-tokens
2. Install the server via pip or uvx (uvx mcp-atlassian)
3. Set JIRA_URL, JIRA_USERNAME, and JIRA_API_TOKEN environment variables
4. Add the server block to your Claude Desktop or Claude Code MCP config file
5. Restart your MCP client and verify the Jira tools appear in the tool list