Jira

Project management and issue tracking integration with Atlassian Jira.

Provider: Atlassian Jira
Authentication: API Token required
Category: Productivity & Project Management
Credit Cost: 1-2 credits per operation

Overview

Jira tools enable AI agents to create, update, search, and manage issues in your Jira projects. Perfect for automating project management workflows, syncing data between systems, and building intelligent ticket handling.

Setup

Get Jira API Token

Go to Atlassian API Tokens
Click Create API token
Give it a descriptive name (e.g., "Reeva MCP")
Copy the generated token (you won't see it again)

Add to Reeva

Dashboard → Accounts → Add Account
Select Jira
Fill in the required fields:
- Site URL: Your Jira instance URL (e.g., https://yourcompany.atlassian.net)
- Email: Your Atlassian account email
- API Token: The token you created
Click Save

Link to Custom Tool

When creating a custom tool:

Select the Jira base tool
Choose your Jira account from the credentials dropdown
Optionally set default parameters (e.g., default project)

Available Tools

Create Issue

Create a new issue in Jira with customizable fields.

Tool ID: jira_Create_Issue
Credit Cost: 2 credits

Parameters:

project_key (string, required): The project key (e.g., "PROJ")
summary (string, required): The issue summary/title
description (string, optional): The issue description
issue_type (string, optional): Issue type
- Default: "Task"
- Common options: "Task", "Bug", "Story", "Epic", "Sub-task"
assignee (string, optional): Assignee's username or email
priority (string, optional): Issue priority
- Options: "Highest", "High", "Medium", "Low", "Lowest"
labels (array, optional): List of labels
components (array, optional): List of component names
fix_versions (array, optional): List of fix version names
parent_key (string, optional): Parent issue key for sub-tasks

Response:

{
  "id": "10001",
  "key": "PROJ-123",
  "self": "https://yourcompany.atlassian.net/rest/api/3/issue/10001"
}

Example Usage:

# Python - Create a basic task
response = client.call_tool(
    name="jira_Create_Issue",
    arguments={
        "project_key": "PROJ",
        "summary": "Implement new feature",
        "description": "Add user authentication to the dashboard",
        "issue_type": "Task",
        "priority": "High"
    }
)

print(f"Created issue: {response['key']}")

// TypeScript - Create bug with labels
const response = await client.callTool({
  name: "jira_Create_Issue",
  arguments: {
    project_key: "PROJ",
    summary: "Fix login button not working on mobile",
    description: "Users report the login button is unresponsive on iOS Safari",
    issue_type: "Bug",
    priority: "Highest",
    labels: ["mobile", "urgent", "safari"],
    assignee: "john.doe@company.com"
  }
});

console.log(`Bug created: ${response.key}`);

# cURL - Create a story
curl -X POST https://api.joinreeva.com/mcp/server_YOUR_ID \
  -H "Authorization: Bearer mcpk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "jira_Create_Issue",
      "arguments": {
        "project_key": "PROJ",
        "summary": "User can reset password",
        "issue_type": "Story",
        "labels": ["auth", "user-management"]
      }
    },
    "id": 1
  }'

Use Cases:

Automatically create tickets from customer feedback
Generate issues from monitoring alerts
Create tasks from Slack messages or emails
Build issues from form submissions

Get Issue

Retrieve detailed information about a specific issue.

Tool ID: jira_get_issue
Credit Cost: 1 credit

Parameters:

issue_key (string, required): The issue key (e.g., "PROJ-123")
fields (string, optional): Specific fields to return, comma-separated
- Example: "summary,status,assignee,priority"
- Default: Returns all fields

Response:

{
  "id": "10001",
  "key": "PROJ-123",
  "fields": {
    "summary": "Implement new feature",
    "description": "Add user authentication...",
    "status": {
      "name": "In Progress",
      "statusCategory": {
        "key": "indeterminate"
      }
    },
    "assignee": {
      "displayName": "John Doe",
      "emailAddress": "john.doe@company.com"
    },
    "priority": {
      "name": "High"
    },
    "created": "2025-11-22T10:30:00.000+0000",
    "updated": "2025-11-22T15:45:00.000+0000"
  }
}

Example Usage:

# Python - Get full issue details
response = client.call_tool(
    name="jira_get_issue",
    arguments={"issue_key": "PROJ-123"}
)

issue = response
print(f"Summary: {issue['fields']['summary']}")
print(f"Status: {issue['fields']['status']['name']}")
print(f"Assignee: {issue['fields']['assignee']['displayName']}")

// TypeScript - Get specific fields only
const response = await client.callTool({
  name: "jira_get_issue",
  arguments: {
    issue_key: "PROJ-456",
    fields: "summary,status,priority,assignee"
  }
});

console.log(`${response.key}: ${response.fields.status.name}`);

Use Cases:

Check issue status in workflows
Retrieve issue details for reporting
Validate issues exist before updating
Display issue information in dashboards

Update Issue

Update an existing issue with new field values.

Tool ID: jira_update_issue
Credit Cost: 2 credits

Parameters:

issue_key (string, required): The issue key to update (e.g., "PROJ-123")
summary (string, optional): Updated summary/title
description (string, optional): Updated description
assignee (string, optional): Updated assignee's username or email
priority (string, optional): Updated priority
labels (array, optional): Updated list of labels
components (array, optional): Updated component names
fix_versions (array, optional): Updated fix version names
status (string, optional): New status (e.g., "In Progress", "Done")
comment (string, optional): Comment to add when updating

Response:

{
  "success": true,
  "key": "PROJ-123",
  "message": "Issue updated successfully"
}

Example Usage:

# Python - Update status and add comment
response = client.call_tool(
    name="jira_update_issue",
    arguments={
        "issue_key": "PROJ-123",
        "status": "In Progress",
        "assignee": "jane.smith@company.com",
        "comment": "Starting work on this feature"
    }
)

// TypeScript - Update priority and labels
const response = await client.callTool({
  name: "jira_update_issue",
  arguments: {
    issue_key: "PROJ-456",
    priority: "Highest",
    labels: ["urgent", "production-issue"],
    comment: "Escalating due to customer impact"
  }
});

# cURL - Close an issue
curl -X POST https://api.joinreeva.com/mcp/server_YOUR_ID \
  -H "Authorization: Bearer mcpk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "jira_update_issue",
      "arguments": {
        "issue_key": "PROJ-123",
        "status": "Done",
        "comment": "Completed and deployed to production"
      }
    },
    "id": 1
  }'

Use Cases:

Automatically update status based on CI/CD events
Reassign issues based on workload
Add automated comments from other systems
Bulk update issue labels

Delete Issue

Delete an existing Jira issue.

Tool ID: jira_delete_issue
Credit Cost: 1 credit

Parameters:

issue_key (string, required): The issue key to delete (e.g., "PROJ-123")
delete_subtasks (boolean, optional): Whether to delete sub-tasks as well
- Default: false

Response:

{
  "success": true,
  "message": "Issue PROJ-123 deleted successfully"
}

Example Usage:

# Python - Delete single issue
response = client.call_tool(
    name="jira_delete_issue",
    arguments={"issue_key": "PROJ-999"}
)

// TypeScript - Delete issue with subtasks
const response = await client.callTool({
  name: "jira_delete_issue",
  arguments: {
    issue_key: "PROJ-500",
    delete_subtasks: true
  }
});

Use Cases:

Clean up test issues
Remove duplicate tickets
Automate cleanup workflows
Delete spam or invalid issues

Warning: Deletion is permanent. Consider updating status to "Cancelled" instead for audit trails.

Search Issues

Search for issues using JQL (Jira Query Language).

Tool ID: jira_search_issues
Credit Cost: 2 credits

Parameters:

jql (string, required): JQL query string
max_results (integer, optional): Maximum results to return
- Default: 50
- Range: 1-1000
fields (array, optional): Specific fields to return
- Default: ["*all"]
- Example: ["summary", "status", "assignee"]
expand (array, optional): Fields to expand
- Example: ["changelog", "comments"]

Response:

{
  "total": 42,
  "issues": [
    {
      "id": "10001",
      "key": "PROJ-123",
      "fields": {
        "summary": "Issue title",
        "status": {"name": "To Do"},
        "assignee": {"displayName": "John Doe"}
      }
    }
  ]
}

Example Usage:

# Python - Find all open bugs
response = client.call_tool(
    name="jira_search_issues",
    arguments={
        "jql": 'project = PROJ AND type = Bug AND status != Done',
        "max_results": 100,
        "fields": ["summary", "status", "priority", "assignee"]
    }
)

print(f"Found {response['total']} open bugs")
for issue in response["issues"]:
    print(f"  {issue['key']}: {issue['fields']['summary']}")

// TypeScript - Find assigned issues
const response = await client.callTool({
  name: "jira_search_issues",
  arguments: {
    jql: 'assignee = currentUser() AND status = "In Progress"',
    max_results: 20
  }
});

# cURL - Search high priority issues
curl -X POST https://api.joinreeva.com/mcp/server_YOUR_ID \
  -H "Authorization: Bearer mcpk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "jira_search_issues",
      "arguments": {
        "jql": "priority = Highest AND status != Done ORDER BY created DESC",
        "max_results": 10
      }
    },
    "id": 1
  }'

Common JQL Examples:

Query	Description
`project = PROJ`	All issues in project
`assignee = currentUser()`	Assigned to API user
`status = "To Do"`	Issues in To Do status
`priority = High`	High priority issues
`created >= -7d`	Created in last 7 days
`updated >= startOfDay()`	Updated today
`labels in (urgent, production)`	Has any of these labels
`type = Bug AND status != Done`	Open bugs

Use Cases:

Generate reports and dashboards
Find overdue or stale issues
Monitor sprint progress
Build issue analytics

Get Projects

List all accessible projects in Jira.

Tool ID: jira_get_projects
Credit Cost: 1 credit

Parameters:

expand (string, optional): Fields to expand, comma-separated
- Example: "description,lead"

Response:

{
  "projects": [
    {
      "id": "10000",
      "key": "PROJ",
      "name": "My Project",
      "projectTypeKey": "software"
    },
    {
      "id": "10001",
      "key": "OPS",
      "name": "Operations",
      "projectTypeKey": "service_desk"
    }
  ]
}

Example Usage:

# Python - List all projects
response = client.call_tool(
    name="jira_get_projects",
    arguments={}
)

for project in response["projects"]:
    print(f"{project['key']}: {project['name']}")

// TypeScript - Get projects with details
const response = await client.callTool({
  name: "jira_get_projects",
  arguments: {
    expand: "description,lead"
  }
});

response.projects.forEach(p => {
  console.log(`${p.key}: ${p.name} (Lead: ${p.lead?.displayName})`);
});

Use Cases:

Validate project keys before creating issues
Build project selection dropdowns
Discover available projects for new users
Generate project inventories

Get Project Issue Types

Get available issue types for a specific project.

Tool ID: jira_get_project_issue_types
Credit Cost: 1 credit

Parameters:

project_key (string, required): The project key (e.g., "PROJ")

Response:

{
  "issue_types": [
    {
      "id": "10001",
      "name": "Task",
      "description": "A task that needs to be done",
      "subtask": false
    },
    {
      "id": "10002",
      "name": "Bug",
      "description": "A problem or error",
      "subtask": false
    },
    {
      "id": "10003",
      "name": "Story",
      "description": "A user story",
      "subtask": false
    },
    {
      "id": "10004",
      "name": "Sub-task",
      "description": "A subtask of an issue",
      "subtask": true
    }
  ]
}

Example Usage:

# Python - Get issue types before creating
response = client.call_tool(
    name="jira_get_project_issue_types",
    arguments={"project_key": "PROJ"}
)

print("Available issue types:")
for issue_type in response["issue_types"]:
    print(f"  - {issue_type['name']}: {issue_type['description']}")

// TypeScript - Validate issue type
const response = await client.callTool({
  name: "jira_get_project_issue_types",
  arguments: {
    project_key: "PROJ"
  }
});

const validTypes = response.issue_types.map(t => t.name);
if (validTypes.includes("Epic")) {
  console.log("Epics are supported in this project");
}

Use Cases:

Validate issue types before creating issues
Build dynamic issue type selectors
Discover project-specific issue types
Handle project configuration differences

Common Patterns

Issue Triage Workflow

# Automatically triage incoming issues
def triage_issue(issue_key):
    # Get issue details
    issue = client.call_tool(
        name="jira_get_issue",
        arguments={"issue_key": issue_key}
    )
    
    summary = issue["fields"]["summary"].lower()
    
    # Auto-categorize based on keywords
    if "bug" in summary or "error" in summary or "broken" in summary:
        priority = "High"
        labels = ["needs-triage", "potential-bug"]
    elif "feature" in summary or "enhancement" in summary:
        priority = "Medium"
        labels = ["feature-request"]
    else:
        priority = "Medium"
        labels = ["needs-triage"]
    
    # Update the issue
    client.call_tool(
        name="jira_update_issue",
        arguments={
            "issue_key": issue_key,
            "priority": priority,
            "labels": labels,
            "comment": "Automatically triaged by AI agent"
        }
    )

Sprint Report

# Generate sprint status report
def sprint_report(project_key, sprint_name):
    # Search for sprint issues
    issues = client.call_tool(
        name="jira_search_issues",
        arguments={
            "jql": f'project = {project_key} AND sprint = "{sprint_name}"',
            "fields": ["summary", "status", "assignee", "storyPoints"]
        }
    )
    
    # Categorize by status
    status_counts = {}
    for issue in issues["issues"]:
        status = issue["fields"]["status"]["name"]
        status_counts[status] = status_counts.get(status, 0) + 1
    
    return {
        "total": issues["total"],
        "by_status": status_counts,
        "issues": issues["issues"]
    }

Issue Creation from External Source

# Create Jira issues from customer feedback
def create_from_feedback(feedback):
    # Determine issue type
    if feedback["type"] == "bug":
        issue_type = "Bug"
        priority = "High"
    else:
        issue_type = "Story"
        priority = "Medium"
    
    # Create the issue
    response = client.call_tool(
        name="jira_Create_Issue",
        arguments={
            "project_key": "PROD",
            "summary": feedback["title"],
            "description": f"Customer Feedback:\n\n{feedback['description']}\n\nSubmitted by: {feedback['email']}",
            "issue_type": issue_type,
            "priority": priority,
            "labels": ["customer-feedback", feedback["source"]]
        }
    )
    
    return response["key"]

Bulk Issue Updates

# Update all issues matching criteria
def bulk_update_label(jql, new_label):
    # Find matching issues
    results = client.call_tool(
        name="jira_search_issues",
        arguments={
            "jql": jql,
            "fields": ["key", "labels"]
        }
    )
    
    updated = []
    for issue in results["issues"]:
        current_labels = [l for l in issue["fields"].get("labels", [])]
        current_labels.append(new_label)
        
        client.call_tool(
            name="jira_update_issue",
            arguments={
                "issue_key": issue["key"],
                "labels": current_labels
            }
        )
        updated.append(issue["key"])
    
    return updated

JQL Reference

Operators

Operator	Description	Example
`=`	Equals	`status = "To Do"`
`!=`	Not equals	`status != Done`
`>`, `<`, `>=`, `<=`	Comparison	`created >= -7d`
`~`	Contains	`summary ~ "login"`
`!~`	Does not contain	`summary !~ "test"`
`IN`	In list	`status IN ("To Do", "In Progress")`
`NOT IN`	Not in list	`priority NOT IN (Low, Lowest)`
`IS EMPTY`	Field is empty	`assignee IS EMPTY`
`IS NOT EMPTY`	Field has value	`labels IS NOT EMPTY`

Date Functions

Function	Description
`startOfDay()`	Beginning of today
`endOfDay()`	End of today
`startOfWeek()`	Beginning of week
`startOfMonth()`	Beginning of month
`-1d`, `-7d`, `-30d`	Relative days
`-1w`, `-2w`	Relative weeks

Common Queries

# Open issues assigned to me
assignee = currentUser() AND status != Done

# High priority bugs
type = Bug AND priority IN (Highest, High) AND status != Done

# Recently updated
updated >= -24h

# Created this sprint
sprint = "Sprint 42"

# Unassigned issues needing attention
assignee IS EMPTY AND priority = High

# Overdue issues
duedate < now() AND status != Done

Best Practices

Credentials

Use a dedicated service account for API access
Rotate API tokens regularly
Grant minimum necessary project permissions
Store credentials securely in Reeva

Performance

Use specific JQL queries to limit results
Request only needed fields with fields parameter
Use pagination for large result sets
Cache project and issue type metadata

Reliability

Validate project keys before creating issues
Check issue types exist in target project
Handle rate limits gracefully
Log all issue modifications for audit

Workflow Integration

Use comments to track automated actions
Add labels to identify AI-created issues
Link related issues when creating
Follow team naming conventions

Troubleshooting

"Issue does not exist" Error

Cause: Invalid issue key or no access

Solutions:

Verify issue key format (PROJECT-123)
Check user has access to the project
Confirm issue hasn't been deleted

"Cannot transition issue" Error

Cause: Invalid status transition

Solutions:

Check valid transitions for current status
Some statuses require specific workflows
Verify user has transition permissions

"Field is required" Error

Cause: Project requires additional fields

Solutions:

Check project's required fields
Different issue types may have different requirements
Use get_project_issue_types to discover requirements

Rate Limiting

Cause: Too many API requests

Solutions:

Add delays between bulk operations
Batch operations where possible
Use JQL to filter server-side

Notion - Alternative project management
N8N - Workflow automation
Supabase - Store issue analytics
Web Search - Research before creating issues

Overview​

Setup​

Get Jira API Token​

Add to Reeva​

Link to Custom Tool​

Available Tools​

Create Issue​

Get Issue​

Update Issue​

Delete Issue​

Search Issues​

Get Projects​

Get Project Issue Types​

Common Patterns​

Issue Triage Workflow​

Sprint Report​

Issue Creation from External Source​

Bulk Issue Updates​

JQL Reference​

Operators​

Date Functions​

Common Queries​

Best Practices​

Credentials​

Performance​

Reliability​

Workflow Integration​

Troubleshooting​

"Issue does not exist" Error​

"Cannot transition issue" Error​

"Field is required" Error​

Rate Limiting​

Related Tools​

See Also​

Overview

Setup

Get Jira API Token

Add to Reeva

Link to Custom Tool

Available Tools

Create Issue

Get Issue

Update Issue

Delete Issue

Search Issues

Get Projects

Get Project Issue Types

Common Patterns

Issue Triage Workflow

Sprint Report

Issue Creation from External Source

Bulk Issue Updates

JQL Reference

Operators

Date Functions

Common Queries

Best Practices

Credentials

Performance

Reliability

Workflow Integration

Troubleshooting

"Issue does not exist" Error

"Cannot transition issue" Error

"Field is required" Error

Rate Limiting

Related Tools

See Also