Iván Fernández

Software Engineering Director at Skillwell.

5 minute read

Connect GitHub Copilot with Jira using the Atlassian Rovo MCP Server to enable real-time interaction with Jira, Compass, and Confluence data directly from your development environment.

This guide walks you through the setup and verification process.

For more details, see the official guide: Getting started with the Atlassian Rovo MCP Server.

Atlassian Rovo MCP Server

The Atlassian Rovo MCP Server is Atlassian’s official implementation of the Model Context Protocol (MCP) that connects Atlassian’s tools with your LLM, IDE, or agent platforms of choice.

See the atlassian-mcp-server GitHub repository for more details.

Supported authentication methods

Atlassian Rovo MCP Server supports two authentication methods:

Method Best for Header
OAuth 2.1 Interactive, user-driven tools Authorization: Bearer <access_token>
API token Non-interactive and machine-to-machine scenarios Authorization: Basic <base64(email:api_token)> or Authorization: Bearer <api_key>

Authenticate via OAuth 2.1

OAuth 2.1 is the primary authentication mechanism for the Atlassian Rovo MCP Server. It uses an interactive consent flow and preserves user context.

When to use OAuth 2.1

Use OAuth 2.1 when:

  • a user is present and can complete the consent flow
  • you want user-level consent and context
  • you are using interactive apps or integrations

Steps to authenticate via OAuth 2.1

  1. When prompted by your tool (e.g., Copilot CLI, Copilot Chat, or IDE plugin), select Sign in with Atlassian.
  2. A browser window will open. Log in with your Atlassian account.
  3. Review the requested permissions and grant access.
  4. After consent, the tool completes authentication automatically.

For more details, see the Configuring OAuth 2.1 guide and the authentication and authorization overview.

Authenticate via API token

API token authentication is available only if your organization admin has enabled it.

When to use API token

Use API token authentication when:

  • no user is present
  • you need non-interactive, machine-to-machine access
  • you can securely manage token storage, rotation, and audit

Enable API token authentication

  1. Go to Atlassian Administration and select your organization.
  2. Select Rovo → Rovo MCP server.
  3. Under Authentication methods, enable API token.

See the authentication configuration instructions.

Create an API token

  1. Log in to your Atlassian account.
  2. Select your profile icon → Account settings → Security.
  3. Under API tokens, click Create and manage API tokens.
  4. Click Create API token with scopes.
    • Give it a name (for example, “Copilot CLI”) and select the expiry date.
    • Select the apps you’d like this API token to access (for example, Jira and Rovo MCP).
    • Select the scopes for the token (for example, read:jira-user and read:jira-work).
    • Create the token and copy it to a secure location.

For more details, see the Manage API tokens for your Atlassian account guide.

Configure GitHub Copilot IntelliJ plugin

  1. Open Settings → Tools → GitHub Copilot → Model Context Protocol.
  2. Under Model Context Protocol, select Configure.

  3. Add a new MCP Server configuration with the following details:

    {
  "servers": {
    "com.atlassian/atlassian-mcp-server": {
      "type": "http",
      "url": "https://mcp.atlassian.com/v1/mcp",
      "x-metadata": {
        "registry": {
          "api": {
            "baseUrl": "https://api.mcp.github.com",
            "version": "v0.1"
          },
          "mcpServer": {
            "name": "com.atlassian/atlassian-mcp-server",
            "version": "1.1.1"
          }
        }
      }
    }
  }
}

Alternatively, install it from the MCP Server Registry:

  1. Open GitHub Copilot Chat.
    • View → Tool Windows → GitHub Copilot Chat.
  2. Click the MCP Registry icon in the top right corner.
  3. Search for Atlassian Rovo MCP Server and click Install.

Start the MCP Server

  1. Open the Model Context Protocol server configuration file: mcp.json.
  2. Click Start above the com.atlassian/atlassian-mcp-server server entry.

Grant access

The Atlassian Rovo MCP Server uses OAuth 2.1 as its primary authentication mechanism, which requires you to grant access to your Atlassian account.

  1. When prompted, a browser window will open.
  2. Grant access to your Jira site as instructed.

For more details, see Authentication and authorization.

Verify the connection

  1. Open the GitHub Copilot MCP Log:
    • View → Tool Windows → GitHub Copilot MCP Log.
  2. Select the server: com.atlassian/atlassian-mcp-server.
  3. Confirm that the connection is successful and no errors are reported.

Test the integration

To verify everything is working, try the following prompt in Copilot Chat:

can you read the summary of this jira task <your-jira-task>

Configure Copilot cloud agent

  1. On GitHub, navigate to your repository.
  2. Go to Settings → ** Copilot** → Cloud agent.
  3. Under Model Context Protocol (MCP), add a new MCP Server configuration with the following details:
{
  "mcpServers": {
    "atlassian-rovo-mcp": {
      "command": "npx",
      "type": "local",
      "tools": [
        "*"
      ],
      "args": [
        "mcp-remote@latest",
        "https://mcp.atlassian.com/v1/mcp",
        "--header",
        "Authorization: Basic $ATLASSIAN_API_KEY"
      ],
      "env": {
        "ATLASSIAN_API_KEY": "$COPILOT_MCP_ATLASSIAN_API_KEY"
      }
    }
  }
}

See Extending GitHub Copilot cloud agent with the Model Context Protocol (MCP)

Configure GitHub Copilot CLI

Install the GitHub Copilot CLI if you haven’t already:

   npm install -g @github/copilot-cli

Configure authentication with OAuth 2.1

  1. Configure the MCP Server in the Copilot CLI configuration file (~/.copilot/config.json) with the following details:

     {
   "mcpServers": {
     "atlassian-rovo-mcp": {
       "type": "http",
       "url": "https://mcp.atlassian.com/v1/mcp/authv2",
       "headers": {},
       "tools": [
         "*"
       ]
     }
   }
 }

  2. When you run a Copilot CLI command that requires access to the MCP Server, you will be prompted to authenticate via OAuth 2.1. Follow the instructions to complete the authentication flow.

Configure authentication with an API token

  1. Create an API token in your Atlassian account with the necessary scopes (e.g., read:jira-user,read:jira-work, etc.).

  2. Base64‑encode the credentials:

     # Format: email:api_token
 echo -n "your.email@example.com:YOUR_API_TOKEN_HERE" | base64
  3. Configure the MCP Server in the Copilot CLI configuration file (~/.copilot/config.json) with the following details:
{
  "mcpServers": {
    "atlassian-rovo-mcp": {
      "url": "https://mcp.atlassian.com/v1/mcp",
      "headers": {
        "Authorization": "Basic <base64(email:api_token)>"
      }
    }
  }
}

For more details, see the official documentation: Configuring authentication via API token.

Update custom instructions for coding agents

Update your AGENTS.md with the Markdown below to reduce discovery tool calls, save time and tokens, and set maximum search results.


## Atlassian Rovo MCP

When connected to atlassian-rovo-mcp:

- **MUST** use Jira project key = YOURPROJ
- **MUST** use Confluence spaceId = "123456"
- **MUST** use cloudId = "https://yoursite.atlassian.net" (do NOT call getAccessibleAtlassianResources)
- **MUST** use `maxResults: 10` or `limit: 10` for ALL Jira JQL and Confluence CQL search operations.

See Tips and tricks in the atlassian-mcp-server documentation for more recommendations on optimizing your integration.

mcp-atlassian

mcp-atlassian is an open-source MCP Server implementation for Atlassian products, including Jira, Confluence, and Compass.

This project provides a reference implementation of an MCP Server that connects to Atlassian’s APIs, enabling developers to build their own integrations or use it as a starting point for their MCP Server development.

Configuration

To configure the mcp-atlassian server, update the MCP configuration file (mcp.json) with the following details:

{
  "mcpServers": {
    "mcp-atlassian": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "mcp-atlassian"
      ],
      "env": {
        "JIRA_URL": "https://yourjirasite.atlassian.net",
        "JIRA_USERNAME": "your.email@example.com",
        "JIRA_API_TOKEN": "$"
      },
      "tools": [
        "*"
      ]
    }
  }
}

Other resources

You May Also Enjoy

Gemini CLI and Miro AI

1 minute read

This guide covers how to integrate Gemini CLI and Miro AI for enhanced software development and project management workflows.