# Jira Cloud MCP

> Jira Cloud MCP connects your AI agent directly into project management workflows. It lets you read, write, and move issues across complex development projects. Use it to find specific tasks using powerful query language, update status, add comments, or create new bug reports—all without opening the Jira website. Manage entire software development lifecycles from your chat interface.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** agile, issue-tracking, jql, task-management, workflow-automation, sprint-planning

## Description

This MCP gives your agent a complete view of project management tools like Jira Cloud. You can pull detailed information on any issue, whether you need to know its current status, who it's assigned to, or which sprints are planned. If you ever struggle with too many disconnected systems for development work, this tool helps centralize that data flow. When your agent retrieves details using the core retrieval tools, it doesn't just grab text; it gets structured context—priority levels, custom fields, and full history. For a catalog of integrations like this, Vinkius makes connecting simple. You can write new tasks, track down bugs with specific search criteria, or move an issue from 'To Do' to 'In Progress' directly through your chat interface.

## Tools

### transition_issue
Moves an existing Jira task to a different workflow status, like moving it from 'To Do' to 'In Progress'.

### add_comment
Adds a public comment directly into the issue's activity timeline for all project members to see.

### assign_issue
Changes who is responsible for an issue, either by assigning it to a specific user or unassigning it completely.

### create_issue
Generates a brand new Jira task, bug report, or story with specified details and initial priority.

### get_issue
Retrieves all detailed information for one specific issue key, including its history, status, and comments.

### get_myself
Provides the agent with current user details to verify identity or check permissions before making changes.

### list_projects
Returns a list of all projects you have access to, providing their keys and names for accurate targeting.

### list_sprints
Lists the current sprints associated with a specific Jira agile board ID.

### list_statuses
Gives a full list of all possible workflow statuses (like 'In Progress' or 'Blocked') across your entire Jira instance.

### list_transitions
Shows the valid next steps and required IDs to move an issue from its current status.

### get_project
Fetches high-level details about a specific project, such as its lead or configured issue types.

### list_dashboards
Lists all available Jira dashboards that you can view for high-level reporting.

### list_issue_types
Provides a list of standard content types like 'Bug', 'Epic', or 'Story' used throughout your projects.

### list_priorities
Lists all defined urgency levels, such as 'High', 'Medium', and 'Low', for task filtering.

### list_users
Returns a directory of every user in your Jira instance by their display name or account ID.

### search_issues
Searches for tasks and bugs using complex filtering rules (JQL) to pinpoint exactly what you need.

### update_issue
Allows modification of specific fields on an existing issue, provided you supply the data in a structured format.

## Prompt Examples

**Prompt:** 
```
List all active projects in Jira.
```

**Response:** 
```
I'll fetch the list of all projects you have access to in Jira.
```

**Prompt:** 
```
Search for all issues assigned to 'user@example.com'.
```

**Response:** 
```
I'll use JQL to find all issues assigned to that specific user.
```

**Prompt:** 
```
Get details for issue 'PROJ-123'.
```

**Response:** 
```
I'll retrieve the full details, including status and priorities, for that Jira issue.
```

## Capabilities

### Find Specific Issues
Search across all projects using Jira Query Language (JQL) to find tasks, bugs, and stories based on complex criteria.

### View Project Details
Retrieve comprehensive information about a specific project, including its lead, general scope, and defined issue types.

### Change Issue Statuses
Move an existing task to the next step in the development workflow using transition IDs.

### Update Task Information
Modify multiple fields on a live issue, such as changing its description or setting a new priority level.

### Add Communication to Issues
Post visible updates and comments that show up in the project's main activity timeline.

## Use Cases

### The Weekly Project Retrospective
A Product Owner needs to know which stories were blocked last week. They ask their agent, and it runs a complex search_issues query (e.g., 'project = MYPROJ AND status = Blocked'). The agent returns the list of keys and the names of the users responsible for unblocking them.

### Handling Bug Reports
A QA tester finds a critical bug, but needs to ensure it lands in the right queue. They use create_issue, specifying 'Bug' as the issue type and setting the priority to 'High,' ensuring immediate visibility for developers.

### Closing Out Development Sprints
The Scrum Master needs to move a batch of tasks that passed QA into the final stage. They instruct the agent to run transition_issue on all relevant keys, moving them from 'Ready for Release' to 'Done.' This updates their workflow instantly.

### Onboarding New Team Members
A new developer needs to understand what a specific project entails. They ask the agent to get_project details using the project key, which returns the scope, lead, and available issue types so they know where to start.

## Benefits

- Eliminate manual status checks. Instead of navigating to a dashboard just to see if 'PROJ-456' moved, your agent runs get_issue and gives you the current state immediately.
- Accelerate triage time. You can search for every bug that has been open for more than 7 days and is assigned to an empty field using search_issues, giving you a clean list of blockers.
- Maintain accurate communication. Need to tell your teammate that you finished reviewing the PR? Use add_comment so the update appears directly on the ticket's timeline, keeping history centralized.
- Streamline task creation. Instead of opening Jira and filling out a form, just tell your agent to create_issue for 'New API endpoint needed,' specifying the priority and type right in the chat.
- Manage ownership instantly. When a bug is fixed, you run assign_issue to hand it off directly to QA without having to manually update the assignee field.

## How It Works

The bottom line is that instead of logging into Jira and clicking through five different screens to manage one ticket, you tell your agent what needs doing, and it handles all the necessary API calls.

1. First, use list_projects to identify the correct project key or use list_users to find specific team members.
2. Next, run search_issues with JQL criteria (e.g., 'project = MYPROJ AND status = Open') and select a target issue using get_issue to pull all necessary context.
3. Finally, tell your agent what change you want—like adding a comment via add_comment or moving the task's priority via update_issue—and it executes the command.

## Frequently Asked Questions

**How do I use search_issues with Jira Cloud MCP?**
You must provide criteria using JQL (Jira Query Language). For example, asking to find all issues where 'project = MARKETING AND status = To Do' will return the relevant keys.

**Can I create an issue with Jira Cloud MCP?**
Yes. You use create_issue and must supply a project key and summary, but you can optionally set the issue type or priority too.

**Which tool do I use to move a ticket status in Jira Cloud MCP?**
You use transition_issue. Note that before running it, you should always run list_transitions first to find the correct ID for that specific workflow change.

**What is the best way to get project context with Jira Cloud MCP?**
Use get_project. This tool gives a high-level overview of the entire project's scope, including its lead and general configuration settings.

**Does Jira Cloud MCP let me change an issue owner?**
Yes, you use assign_issue to change who is responsible for the task by supplying a valid user account ID or display name.