GitHub
GitHub’s official server lets AI read and manage code, issues and pull requests in your account. Use GitHub’s hosted version or run it locally with Docker.
Description from the maker (original English)
Read-only MCP server for self-hosted Atlassian Bamboo CI/CD
These three are never merged into one score: opinions, measurements and popularity are different things.
We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.
Pick the AI app you use, then copy the settings.
BAMBOO_URL, BAMBOO_TOKEN, MCP_TRANSPORT, BAMBOO_PROXY, BITBUCKET_URL, VERBOSEValues marked secret are keys to your account. Never share them or paste them into a chat.
You need
Which app do you use?
Pick your app above. We remember it, so next time the button says “Install in …”.
Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json
{
"mcpServers": {
"bamboo": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"BAMBOO_URL",
"-e",
"BAMBOO_TOKEN",
"-e",
"MCP_TRANSPORT",
"-e",
"BAMBOO_PROXY",
"-e",
"BITBUCKET_URL",
"-e",
"VERBOSE",
"ghcr.io/hmdmph/bamboo-mcp:0.1.2"
],
"env": {
"BAMBOO_URL": "your-value",
"BAMBOO_TOKEN": "your-value",
"MCP_TRANSPORT": "your-value",
"BAMBOO_PROXY": "your-value",
"BITBUCKET_URL": "your-value",
"VERBOSE": "your-value"
}
}
}
}Run this in your terminal
claude mcp add bamboo --env BAMBOO_URL=your-value --env BAMBOO_TOKEN=your-value --env MCP_TRANSPORT=your-value --env BAMBOO_PROXY=your-value --env BITBUCKET_URL=your-value --env VERBOSE=your-value -- docker run -i --rm -e BAMBOO_URL -e BAMBOO_TOKEN -e MCP_TRANSPORT -e BAMBOO_PROXY -e BITBUCKET_URL -e VERBOSE ghcr.io/hmdmph/bamboo-mcp:0.1.2Fill in the empty values before running it.
Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json
{
"mcpServers": {
"bamboo": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"BAMBOO_URL",
"-e",
"BAMBOO_TOKEN",
"-e",
"MCP_TRANSPORT",
"-e",
"BAMBOO_PROXY",
"-e",
"BITBUCKET_URL",
"-e",
"VERBOSE",
"ghcr.io/hmdmph/bamboo-mcp:0.1.2"
],
"env": {
"BAMBOO_URL": "your-value",
"BAMBOO_TOKEN": "your-value",
"MCP_TRANSPORT": "your-value",
"BAMBOO_PROXY": "your-value",
"BITBUCKET_URL": "your-value",
"VERBOSE": "your-value"
}
}
}
}Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.
Paste into .vscode/mcp.json in your project
{
"servers": {
"bamboo": {
"type": "stdio",
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"BAMBOO_URL",
"-e",
"BAMBOO_TOKEN",
"-e",
"MCP_TRANSPORT",
"-e",
"BAMBOO_PROXY",
"-e",
"BITBUCKET_URL",
"-e",
"VERBOSE",
"ghcr.io/hmdmph/bamboo-mcp:0.1.2"
],
"env": {
"BAMBOO_URL": "your-value",
"BAMBOO_TOKEN": "your-value",
"MCP_TRANSPORT": "your-value",
"BAMBOO_PROXY": "your-value",
"BITBUCKET_URL": "your-value",
"VERBOSE": "your-value"
}
}
}
}Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.
This one runs on your computer, and ChatGPT can only connect to servers on the internet. Pick another app.
Your choice stays on this device in a cookie; no account needed.
BAMBOO_PROXY envBITBUCKET_URL envVERBOSE envThese settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.
Runs on your computer; the tool list appears in your AI app after you install it.
We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 8, 2026
The registry name was verified with the GitHub account hmdmph, which owns the repo
We have not read this repo from GitHub yet
We have not read this repo from GitHub yet
This one runs on your computer; there is no internet endpoint
Runs on your computer and uses local settings instead
Runs on your computer; we can only read tool lists from internet endpoints
Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.
It passed 1 of 1 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.
You need to fill in: BAMBOO_URL, BAMBOO_TOKEN, MCP_TRANSPORT
It runs on your computer. Your AI app starts it when needed, and data does not pass through the maker’s servers (unless it calls an online service itself).
The GitHub repo last changed –, and the latest version (0.1.2) reached the registry 3 months ago.
Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. You also need Docker on your computer.
In the same category: GitHub, Desktop Commander, Cloudflare MCP
Servers in the same category from other makers, sorted by stars.
Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi
GitHub’s official server lets AI read and manage code, issues and pull requests in your account. Use GitHub’s hosted version or run it locally with Docker.
MCP server for terminal commands, file operations, and process management
Cloudflare MCP servers
Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.
A Model Context Protocol server that exposes a self-hosted Atlassian Bamboo instance to AI assistants — Claude Desktop, Claude Code, Cursor, Windsurf, or any other MCP client.
Ask *"who deployed CHECKOUT to staging and did it pass?"* instead of clicking through the Bamboo UI.
Read-only by design. Every tool is registered behind a policy engine that enforces a GET-only floor. This server cannot trigger a build, start a deployment, or change anything in Bamboo.
Atlassian has announced the end of support for Bamboo Data Center in 2029. If you are starting a new CI/CD project, you should be looking at a supported platform instead — check Atlassian's end-of-life policy for the current dates.
That said, plenty of organisations are still running Bamboo Server / Data Center today and will be for years, often with hundreds of plans and deployment projects accumulated over a decade. This project exists for those teams: if you are living with Bamboo until the migration lands, this makes the day-to-day "what's deployed where, and who broke it" questions a lot cheaper to answer.
Contributions are welcome, but be aware you are building on a platform with a known sunset.
Server & projects (5)
| Tool | What it does |
|---|---|
bamboo_server_info | Bamboo server version and build info |
bamboo_health_check | Reachability and auth check |
bamboo_list_projects | List projects (paginated) |
bamboo_list_all_projects | List every project (auto-paginated) |
bamboo_get_project | Details for one project |
Plans & branches (5)
| Tool | What it does |
|---|---|
bamboo_list_plans | List all build plans |
bamboo_get_plan | Details for one plan |
bamboo_search_plans | Search plans by name |
bamboo_list_plan_branches | Branch plans for a plan |
bamboo_get_plan_branch | Details for one branch plan |
Builds (7)
| Tool | What it does |
|---|---|
bamboo_get_latest_result | Latest build result for a plan |
bamboo_list_build_results | Recent build results |
bamboo_get_build_result | One build result |
bamboo_get_build_result_expanded | Build result plus changes, artifacts, stages, metadata and log URLs |
bamboo_get_build_repositories | Repositories and commits for a build |
bamboo_get_plan_repositories | Repositories configured on a plan |
bamboo_get_build_queue | What's currently queued |
Deployments (8)
| Tool | What it does |
|---|---|
bamboo_list_deployment_projects | All deployment projects |
bamboo_list_deployment_projects_for_plan | Deployment projects linked to a build plan |
bamboo_get_deployment_project | Deployment project + its environments |
bamboo_get_environment_results | Deployment history for an environment — who, when, status, version |
bamboo_get_deployment_result | Full detail of one deployment (trigger, timing, agent) |
bamboo_list_deploy_versions | Releases/versions for a deployment project |
bamboo_get_deploy_version | One version (creator, plan branch, items) |
bamboo_get_deploy_version_status | Where a given version sits across all environments |
Plan context — the "smart" tools (6)
These are what make the server useful rather than just a REST wrapper. They read a YAML file describing *your* plan-key and environment naming conventions, so the model can go from a human reference to a Bamboo key without you spelling it out.
| Tool | What it does |
|---|---|
bamboo_resolve_plan | CHECKOUT + app → EXAMPLE-CHECKOUTAPP |
bamboo_get_deploy_status | One call: resolve plan → latest build → deployment project → filter environments → per-environment history → Bamboo UI + log links |
bamboo_explain_environment | Parse staging_network_checkout_deploy into env / module / ref / action, with descriptions |
bamboo_get_plan_type_info | Everything known about a plan type: formats, actions, modules, log patterns, custom inputs, hints |
bamboo_get_plan_context | Dump the whole context config |
bamboo_reload_context | Hot-reload the config after you edit it — no restart |
Bitbucket credential storage (4) — optional, see limitations
bitbucket_add_repo, bitbucket_get_repo, bitbucket_list_repos, bitbucket_delete_repo.
Stores repository URL/username/token in ~/.bamboo-mcp/bitbucket.json (mode 0600, tokens masked on read). Nothing else in the server consumes this — Bitbucket links in build results are built from the BITBUCKET_URL environment variable. See limitations.
35 tools total. The full surface — names, descriptions and JSON Schemas — is generated into tools.json, and bamboo-mcp --list-tools prints the same payload without needing a Bamboo connection. See the tool manifest.
MCP prompts give the model a structured plan for common workflows, so you get consistent output instead of ad-hoc tool flailing.
| Prompt | Arguments | Purpose |
|---|---|---|
deploy_status | reference, plan_type, environment, module | Deployment status with per-environment history |
who_deployed_last | reference, environment*, module, plan_type | Who shipped last, and when |
explain_environment | environment_name*, plan_type | Break an env name into its parts |
plan_type_guide | plan_type* | Full guide to a plan type |
build_investigation | build_key* | Investigate a build — changes, stages, log link |
build_repositories | build_key, plan_key | Commits and repos behind a build |
deployment_history | environment_id*, limit | Who deployed what, when, as a table |
resolve_plan | reference*, plan_type | Reference → plan key + latest build |
health_check | — | Full Bamboo health report |
stdio for desktop clients, sse (HTTP) for containers and remote access.SKIP_VALIDATION=true.BAMBOO_PROXY for corporate networks.tools.json and --list-tools, generated from the catalog and verified in CI, with a test that calls every declared tool. See Tests.Requires Go 1.23+ and a Bamboo personal access token.
git clone https://github.com/hmdmph/bamboo-mcp.git
cd bamboo-mcp make build # → bin/bamboo-mcp
export BAMBOO_URL=https://bamboo.example.com export BAMBOO_TOKEN=your_personal_access_token
./bin/bamboo-mcp # stdio mode
Getting a token: Bamboo → your profile → *Personal access tokens* → create. Read permission on the projects you care about is enough; this server never writes.
Prebuilt multi-arch images (linux/amd64, linux/arm64) are published to GHCR on every release:
docker run --rm -p 8080:8080 \
-e BAMBOO_URL=https://bamboo.example.com \ -e BAMBOO_TOKEN=your_token \ ghcr.io/hmdmph/bamboo-mcp:latest
Tags: latest, 1, 1.2, 1.2.3. Or build it yourself:
make docker-build
make docker-run-sse # detached, SSE on :8080
DOCKER_IMAGE=myregistry/bamboo-mcp DOCKER_TAG=v1.0.0 HTTP_PORT=9090 make docker-run-sse make docker-logs make docker-stop
# docker-compose.yml
services: bamboo-mcp: image: bamboo-mcp:latest ports: ["8080:8080"] environment: BAMBOO_URL: https://bamboo.example.com BAMBOO_TOKEN: your-token MCP_TRANSPORT: sse MCP_BASE_URL: http://bamboo-mcp:8080 restart: unless-stopped
Behind a corporate CA? The Dockerfile has commented-out lines near the top for copying your own PEM files into the image — drop them in certs/ and uncomment.
All configuration is environment variables. Copy .env.example to .env.dev to keep them out of git.
| Variable | Default | Purpose |
|---|---|---|
BAMBOO_URL | — | Required. Base URL, e.g. https://bamboo.example.com |
BAMBOO_TOKEN | — | Required. Personal access token (sent as Bearer) |
BAMBOO_PROXY | — | HTTP proxy, e.g. http://proxy.example.com:8080 |
BITBUCKET_URL | — | Base URL used to build source links in build results |
VERBOSE | false | Log requests/responses to stderr |
CONTEXT_FILE | ~/.bamboo-mcp/context.yaml | Plan context config |
SECURITY_FILE | ~/.bamboo-mcp/security.yaml | Security policy config |
SKIP_VALIDATION | false | Start even if Bamboo is unreachable |
MCP_TRANSPORT | stdio | stdio or sse |
MCP_HTTP_HOST | 0.0.0.0 | SSE only |
MCP_HTTP_PORT | 8080 | SSE only |
MCP_BASE_URL | http://localhost:8080 | SSE only — the externally reachable URL |
Note on logging: in stdio mode, stdout carries the MCP protocol stream. All logging goes to stderr — never add
fmt.Printlnto a handler.
~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": { "bamboo": { "command": "/absolute/path/to/bamboo-mcp/bin/bamboo-mcp", "env": { "BAMBOO_URL": "https://bamboo.example.com", "BAMBOO_TOKEN": "your_personal_access_token" } } } }
claude mcp add bamboo /absolute/path/to/bin/bamboo-mcp \
-e BAMBOO_URL=https://bamboo.example.com \ -e BAMBOO_TOKEN=your_personal_access_token
Same shape as Claude Desktop, in the client's MCP settings file.
{
"mcpServers": { "bamboo": { "url": "http://your-server:8080/sse" } } }
The SSE server exposes /sse and /message. It has no authentication of its own — see limitations.
This is the part worth spending ten minutes on.
Most Bamboo estates encode meaning in their plan keys and environment names — something like PROJ-CHECKOUTAPP with environments called staging_network_checkout_deploy. Out of the box an AI assistant has no idea what any of that means. context.yaml tells it.
On first run a starter file is written to ~/.bamboo-mcp/context.yaml. It ships deliberately generic placeholders — the feature only becomes useful once you describe your own conventions. A fully commented, worked example lives in examples/context.yaml.
Only the beginning is shown; read the rest in the repo