Atlassian Mcp

Streamline Atlassian MCP automation and integration workflows

Category: productivity Source: Jeffallan/claude-skills

Atlassian MCP is a community skill for integrating Atlassian products such as Jira and Confluence with AI assistants through the Model Context Protocol, covering issue management, page creation, search queries, and project automation workflows.

What Is This?

Overview

Atlassian MCP provides patterns for connecting AI assistants to Jira and Confluence through the Model Context Protocol server interface. It covers Jira issue creation and updates, Confluence page reading and writing, JQL search execution, sprint management, and project metadata retrieval. The skill enables AI-driven workflows that interact with Atlassian products programmatically while maintaining authentication and permission controls.

Who Should Use This

This skill serves development teams using Jira for project tracking who want AI-assisted issue management, technical writers maintaining Confluence documentation through automated updates, and engineering managers building AI-powered dashboards that pull data from Atlassian projects.

Why Use It?

Problems It Solves

Manually creating and updating Jira issues during development interrupts workflow and leads to incomplete ticket descriptions. Searching across large Jira projects for relevant issues requires remembering JQL syntax and filter configurations. Keeping Confluence documentation synchronized with actual codebase changes requires manual effort that often falls behind. Generating sprint reports and status summaries from Jira data involves repetitive data gathering across multiple board views.

Core Highlights

MCP server interface exposes Atlassian operations as tool calls that AI assistants can invoke directly. JQL query builder constructs search expressions from natural language descriptions. Confluence content management handles page creation, updates, and hierarchy navigation through structured API calls. Authentication flow manages OAuth tokens and API keys securely across sessions.

How to Use It?

Basic Usage

import httpx
from dataclasses import dataclass

@dataclass
class JiraConfig:
    base_url: str
    email: str
    api_token: str

class AtlassianMCPClient:
    def __init__(self, config: JiraConfig):
        self.config = config
        self.client = httpx.Client(
            base_url=f"{config.base_url}/rest/api/3",
            auth=(config.email, config.api_token),
            headers={"Content-Type": "application/json"}
        )

    def create_issue(self, project_key: str, summary: str,
                     description: str, issue_type: str = "Task") -> dict:
        payload = {
            "fields": {
                "project": {"key": project_key},
                "summary": summary,
                "description": {"type": "doc", "version": 1,
                    "content": [{"type": "paragraph",
                        "content": [{"type": "text", "text": description}]}]},
                "issuetype": {"name": issue_type}
            }
        }
        response = self.client.post("/issue", json=payload)
        return response.json()

    def search_issues(self, jql: str, max_results: int = 20) -> list[dict]:
        response = self.client.get("/search",
            params={"jql": jql, "maxResults": max_results})
        return response.json().get("issues", [])

Real-World Examples

class SprintReporter:
    def __init__(self, client: AtlassianMCPClient):
        self.client = client

    def get_sprint_summary(self, project_key: str,
                           sprint_name: str) -> dict:
        jql = (f"project = {project_key} AND sprint = "
               f"\"{sprint_name}\"")
        issues = self.client.search_issues(jql, max_results=100)
        summary = {"total": len(issues), "done": 0,
                   "in_progress": 0, "todo": 0}
        for issue in issues:
            status = issue["fields"]["status"]["statusCategory"]["name"]
            if status == "Done":
                summary["done"] += 1
            elif status == "In Progress":
                summary["in_progress"] += 1
            else:
                summary["todo"] += 1
        summary["completion_rate"] = round(
            summary["done"] / max(summary["total"], 1) * 100, 1)
        return summary

    def generate_report(self, project_key: str,
                        sprint_name: str) -> str:
        data = self.get_sprint_summary(project_key, sprint_name)
        return (f"Sprint: {sprint_name}\n"
                f"Total Issues: {data['total']}\n"
                f"Completed: {data['done']} ({data['completion_rate']}%)\n"
                f"In Progress: {data['in_progress']}\n"
                f"Remaining: {data['todo']}")

Advanced Tips

Use bulk operations when creating or updating multiple issues to reduce API call overhead. Implement webhook listeners that trigger MCP tool updates when Jira issues change status. Cache frequently accessed project metadata to avoid repeated API calls for board and sprint configurations.

When to Use It?

Use Cases

Automate Jira issue creation from code review comments or pull request descriptions. Generate weekly sprint status reports by querying Jira boards through natural language. Synchronize Confluence documentation pages with project README files and API specifications.

Important Notes

Requirements

An Atlassian Cloud account with API token access for authentication. MCP server runtime environment for hosting the Atlassian integration. Appropriate project permissions in Jira and Confluence for the operations being automated.

Usage Recommendations

Do: use JQL queries with specific filters to limit search results and reduce response times. Validate issue field values against project schemas before creating tickets. Test MCP tool operations in a sandbox project before connecting to production boards.

Don't: store API tokens in plaintext configuration files accessible to unauthorized users. Perform bulk deletions or modifications without confirmation steps in the workflow. Ignore pagination when querying large result sets that exceed default page limits.

Limitations

API rate limits restrict the number of operations per minute and may throttle high-volume automation workflows. Atlassian Cloud and Data Center APIs differ in endpoints and authentication methods, requiring separate configurations. Complex Jira workflows with custom fields need additional mapping logic beyond standard field handling. Confluence storage format differs from display format, requiring content conversion for accurate editing.