Atlassian Dc MCP Go
A Go-based Model Context Protocol (MCP) service for managing Atlassian Data Center products (Jira, Confluence, Bitbucket) with unified interface, configurable authentication, and fine-grained permissions. Built with github.com/modelcontextprotocol/go-sdk.
Ask AI about Atlassian Dc MCP Go
Powered by Claude · Grounded in docs
I know everything about Atlassian Dc MCP Go. Ask me about installation, configuration, usage, or troubleshooting.
0/500
Reviews
Documentation
Atlassian Data Center MCP (Model Context Protocol)
Author: Stephen Chen
This project provides a Go-based Model Context Protocol (MCP) service for managing and interacting with Atlassian Data Center products including Jira, Confluence, and Bitbucket. It allows you to manage these products programmatically through a unified interface with configurable authentication and permissions.
Features
- Multi-Product Support: Unified interface for Jira, Confluence, and Bitbucket
- Model Context Protocol: Exposes tools through the Model Context Protocol for all operations
- Configuration Management: Flexible configuration through files, environment variables, and hot reloading
- Authentication: Direct API token authentication for each service
- Permissions: Fine-grained read/write permissions for each service
- Health Monitoring: Built-in health checks for all services
- Docker Support: Ready for containerized deployment
- Reverse Proxy Support: Configurations for Nginx and Traefik with HTTPS support
Running the Application
You can run the application in multiple ways: directly using Go, by building binaries first, or using Docker.
For detailed instructions on running the application:
- Running with Docker - Instructions for running the service using Docker and Docker Compose
- Running locally - Instructions for running the service directly on your system
Reverse Proxy Configuration
For reverse proxy configurations, please refer to the separate documentation:
- Nginx Configuration with mkcert - Instructions for setting up HTTPS access using Nginx
- Traefik Configuration with mkcert - Instructions for setting up HTTPS access using Traefik
- Production Deployment with Let's Encrypt - Instructions for production deployment with automatic SSL certificates
Below are basic commands for development purposes:
Direct Execution
# Run the server
go run cmd/server/main.go
# Run with custom config file path
go run cmd/server/main.go -c /path/to/your/config.yaml
Building and Running Binaries
The project uses a Makefile to simplify the build process. All binaries are placed in the dist directory.
# Show all available commands
make help
# Build the server binary for your current OS
make build
# Build a statically linked release binary
make release
After building the project, you can run the binary directly from the dist directory:
# Run the server
./dist/atlassian-dc-mcp-server
# Run with custom config file path
./dist/atlassian-dc-mcp-server -c /path/to/your/config.yaml
Configuration
The application requires a configuration file to operate. By default, it looks for config.yaml in the current directory, but you can specify a different path using the -c or --config flag.
A sample configuration file is provided as config.yaml.example. Copy this file to config.yaml and edit it with your settings:
cp config.yaml.example config.yaml
The configuration file is self-documented with examples for all available settings. Please refer to the config.yaml.example file for detailed configuration options.
Prune Configuration
The application includes a feature to remove sensitive or unnecessary fields from API responses before returning them to the client. This is configured through the prune section in the configuration file:
fuzzy_keys: List of key prefixes that should be removed from responsesremove_paths: List of exact paths or path suffixes that should be removed
Example:
prune:
fuzzy_keys:
- "customfield"
remove_paths:
- "emailAddress"
- "avatarUrls"
# ... other fields to remove
Authentication Modes
The service supports two authentication modes:
- Config Mode (default): API tokens are read from the configuration file
- Header Mode: API tokens are passed via HTTP headers
To enable header mode, start the server with the -auth-mode=header flag:
./dist/atlassian-dc-mcp-server -auth-mode=header
In header mode, the service expects the following HTTP headers:
Jira-Token: API token for JiraConfluence-Token: API token for ConfluenceBitbucket-Token: API token for Bitbucket
This mode is particularly useful when deploying the service in environments where you want to avoid storing sensitive tokens in configuration files, such as when using the service behind a reverse proxy that handles authentication.
Tools Documentation
Jira Tools
Tools for interacting with Jira:
- Get current user information
- Get issues
- Create issues
- And many more
Confluence Tools
Tools for interacting with Confluence:
- Get current user information
- Get content
- Search content
- And more
Bitbucket Tools
Tools for interacting with Bitbucket:
- Get current user information
- Get repositories
- Get commits
- And more
Lingma Rules
This project includes predefined Lingma rules that demonstrate how to use the Atlassian Data Center MCP service for automated code review tasks. For detailed information on how to use these rules, please refer to the Lingma Rules documentation.
The code_review.md rule file provides an example configuration showing how to leverage the Atlassian Data Center MCP service for automated Bitbucket PR code reviews. These rules help you:
- Automate code review processes using the MCP service
- Standardize code quality and security checks
- Improve interaction efficiency with AI assistants during code reviews
Development
Prerequisites
- Go 1.20 or higher
- Docker (for containerization)
Building
It is recommended to use the Makefile to build the project, which ensures all build artifacts are placed in the unified dist directory:
# Build server binary to dist directory
make build
To build binaries for specific operating systems:
# Build for Linux
make build-linux
# Build for Windows
make build-windows
# Build for macOS
make build-macos
Benefits of using make commands:
- All build artifacts are placed in the
distdirectory - Automatically handles cross-platform builds
- Ensures consistent build parameters
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
License
This project is licensed under the MIT License - see the LICENSE file for details.
