jira-github-mcp

jira-github-mcp is a modular, extensible Model Context Protocol (MCP) server for integrating Jira and GitHub, enabling end-to-end automation of developer workflows through AI agents within the IDE—from issue tracking to code changes and pull request management.

I. Purpose Developers frequently switch contexts between Jira, GitHub, and the IDE, which interrupts focus and slows delivery. This project transforms this process into a seamless, IDE-native conversational experience, allowing developers to use natural language and AI-assisted automation to go from a Jira issue all the way to a merged pull request.

II. Main Capabilities

• Jira integration: fetch issues by filter, search via JQL, transition issue statuses in the workflow.
• GitHub integration: create branches, open and merge PRs.
• Local Git operations: stage, commit, and push changes locally.
• IDE-native: works with any MCP-compatible agent (e.g., GitHub Copilot) via stdio.
• End-to-end workflow: Jira issue → branch → code → commit → PR → merge → Jira status update.
• Provides MCP resources for workflow guidance and current issue context.

III. Available Tools (calls in the example workflow)

• jira_get_my_issues: list issues assigned to the current user.
• jira_search_issues: sort by status or urgency.
• jira_get_issue(issue_key="KAN-42"): fetch the specified issue.
• create_branch_for_issue(issue_key="KAN-42"): create a branch for the issue.
• jira_transition_issue(issue_key="KAN-42", to_status="In Progress"): transition the issue status.
• git_commit_and_push(message="Implement KAN-42", branch="feature/KAN-42"): commit and push changes.
• create_pull_request(issue_key="KAN-42", branch_name="feature/KAN-42"): create a pull request.
• merge_pull_request(pr_number=123): merge a pull request.

IV. Project Structure

• src/: application source code
• server/: MCP server entry point and tool registration
• config/: configuration loading for Jira and GitHub
• providers/: Jira/GitHub API clients and local Git operations
• tools/: MCP tool definitions and implementations
• resources/: MCP resources (workflow guidance, issue context)
• prompts/: AI prompts used internally by the server to guide agent behavior
• tests/: integration and unit tests
• pyproject.toml: project metadata and dependencies
• uv.lock: dependency lock file For complete documentation of the architecture, see docs/architecture.md.

V. Installation and Setup Prerequisites:

• Git (available in PATH)
• A Jira instance (Cloud or self-hosted) with access to REST API v3
• A GitHub repository with token-based API access permissions

Steps:

1. Clone the repository.
2. Create and activate a virtual environment. Use uv (recommended).
3. Install dependencies. Use uv (recommended). The project depends on fastmcp: MCP protocol and server tools.
4. Configure environment variables. Create a .env file in the repository root. Note: JIRA_BASE_URL should not end with /; grant the GitHub PAT only the minimum required permissions (branches, pull requests, etc.).
5. Run the MCP server. Run the server as a Python module; if an entry point is defined, it can also be run via the entry point.
6. Connect from an MCP client. To use it with an MCP client (e.g., VS Code / GitHub Copilot), configure the client to run the server from the project root. In the example MCP configuration, replace /absolute/path/to/mcp-server with the actual path to the repository.

Connecting to GitHub Copilot:

• Open VS Code and make sure GitHub Copilot is installed.
• Sign in with your GitHub account (if not already signed in).
• Configure the MCP serverAdd the configuration to VS Code settings (see the JSON above).
• Start asking Copilot natural language questions—it will automatically invoke the relevant tools.

1. Example Workflow (Complete Process from Issue to Merge)

2. Discover the next task: Ask Copilot "What is the most urgent task assigned to me?". It invokes the tools jira_get_my_issues and jira_search_issues. Select issue KAN-42.

3. Start working on the issue: Ask "Start working on KAN-42". It invokes jira_get_issue(issue_key="KAN-42"), create_branch_for_issue(issue_key="KAN-42"), jira_transition_issue(issue_key="KAN-42", to_status="In Progress"). Then make changes in the editor.

4. Commit the changes: Ask "Commit my changes with the message 'Implement KAN-42'". It invokes git_commit_and_push(message="Implement KAN-42", branch="feature/KAN-42").

5. Create a pull request: Ask "Create a PR for KAN-42". It invokes create_pull_request(issue_key="KAN-42", branch_name="feature/KAN-42") and jira_transition_issue(issue_key="KAN-42", to_status="In Review"). Code review and CI checks run on GitHub.

6. Merge and close the issue: Ask "Merge the PR and move KAN-42 to Done". It invokes merge_pull_request(pr_number=123) and jira_transition_issue(issue_key="KAN-42", to_status="Done"). The issue is closed, the code is merged, and the workflow is complete.

7. Applicable Scenarios

• Daily development workflows involving Jira issues, branches, and pull requests.
• Code review processes with clear pull request status tracking.
• Sprint execution and task progress visibility.
• Quick bug fix and hotfix workflows.
• End-to-end feature development from issue to merge.
• Team collaboration with consistent status and ownership tracking.

1. Limitations and Future Enhancements Future plans include: multi-platform support, extending the integration to platforms beyond GitHub (e.g., GitLab); smarter workflows such as multi-repository support, reusable JQL templates, and configurable automation rules; deeper automation such as AI-assisted PR/commit drafting, webhook-driven synchronization, and CI/CD feedback. This MCP server connects Jira and GitHub through a single conversational interface, reducing manual coordination, keeping issues, branches, and pull requests in sync, and helping teams focus on development rather than process. Its design emphasizes clarity, extensibility, and developer experience.