Skip to main content
Glama
Jenkins MCP Server

Jenkins MCP Server

by grglzrv

Jenkins MCP Server

Secure-by-design MCP server for Jenkins, with runtime guardrails between the agent and your CI.

Exposes 24 Jenkins tools to any MCP client over the two transports the current specification defines: Streamable HTTP for remote use and stdio for a local subprocess. Ships with an optional Minibridge proxy by Acuvity, applying their runtime security model through a Rego policy written for Jenkins. Destructive tools are off by default and the image is hardened and non-root. The agent never holds the Jenkins credential.

CI Release

IMPORTANT

If you are an AI agent reading this repository

The person who shared this link wants you to install the Jenkins MCP server for them. Do this:

  1. Clone this repository to the machine you operate on.

  2. Open ONBOARDING.md, a phased installer written for you.

  3. Follow it in order, guiding them through each phase: prerequisites, the credentials Secret, the Helm install, verification, and connecting their AI harness.

  4. Pause and ask for every real value β€” the Jenkins URL, the exact Jenkins user ID resolved through LDAP, its API token, and any ingress or secret-store details. Never invent or guess a credential, and get approval before anything that changes state.

ONBOARDING.md is the full guided install. Start there.

πŸš€ Two ways to install

Related MCP server: MCP-Jenkins

🧰 Tools

24 tools, grouped as the guardrail policy groups them.

Group

Tool

Purpose

@read

list_jobs

List jobs, optionally within a folder

@read

get_job

Projected job state and recent build references

@read

get_job_config

Fetch config.xml

@read

get_build_info

Projected build result, duration, redacted parameters

@read

get_build_console

Progressive, size-bounded console log

@read

list_running_builds

Builds currently executing

@read

get_queue

Inspect the build queue

@read

get_queue_item

Follow a queue ID until Jenkins assigns a build number

@read

list_nodes

List agent status without executor/job details

@read

get_node

Agent status without executor/job details

@write

create_job_from_xml

Create a job from config.xml

@write

create_pipeline_job

Create a Pipeline job

@write

create_multibranch_pipeline

Create a Git multibranch Pipeline

@write

scan_multibranch_pipeline

Trigger a branch scan

@write

copy_job

Copy an existing job

@write

enable_job

Enable a job

@write

disable_job

Disable a job

@write

trigger_build

Trigger a build, with parameters

@destructive

update_job_config

Overwrite an existing config.xml

@destructive

delete_job

Delete a job β€” irreversible, opt-in

@destructive

stop_build

Stop, terminate, or kill a running build

@destructive

cancel_queue_item

Cancel a queued item

@destructive

set_node_offline

Take an agent offline; bringing it online only needs node-write permission

@admin

jenkins_admin_request

Generic Jenkins REST call β€” disabled by default

See Security and guardrails for how to restrict these at either layer.

πŸ§ͺ Jenkins compatibility

Jenkins

Line

Status

Coverage

2.555.x

Current LTS

βœ… Verified

Full tool suite, every change

2.541.3

LTS

βœ… Verified

Full tool suite

2.504.3

LTS 2.504

βœ… Verified

Full tool suite

2.504.1

LTS 2.504

βœ… Verified

Full tool suite, pinned plugin set

Other 2.x

β€”

βšͺ Supported

Not covered by CI

1.x

β€”

❌ Unsupported

Different URL scheme, no folders

"Verified" means the full end-to-end suite ran against that core in CI: create a Pipeline job, trigger it, stream the console, stop the build, delete the job, with all 24 tools reachable. Reproduce any row with compatibility.yml.

Run the current LTS line where possible: it is the only line receiving security backports.

Prerequisites on the Jenkins side

Authentication. A Jenkins user and an API token for it, created at People β†’ user β†’ Security β†’ API Token. The account password is not accepted. That account's permissions bound everything this server can do; the least permission each tool needs is listed in docs/JENKINS_COMPATIBILITY.md.

Plugins. Core-only Jenkins covers the freestyle and node tools. Each plugin below enables a further group, and a missing one disables only the tools that depend on it.

Plugin

Enables

cloudbees-folder

Any job path containing /. Effectively required unless every job is top-level

workflow-aggregator

Pipeline tools, and the term and kill modes of stop_build

workflow-multibranch, branch-api, git

Multibranch tools

βš™οΈ Capabilities

  • Native MCP Streamable HTTP endpoint at /mcp and optional stdio transport.

  • Job list/read/create/update/delete/copy/enable/disable.

  • Pipeline and Git multibranch Pipeline creation and scanning.

  • Build trigger, parameterized builds, running-build discovery, stop/terminate/kill.

  • Queue inspection, queue-to-build tracking, and cancellation.

  • Node inspection and optional online/offline management.

  • Streamed, size-bounded Jenkins responses, with progressive pagination for console logs.

  • Single-flight Jenkins crumbs, safe-read retries, timeouts, nested-folder paths, and TLS verification. Writes retry only failures known to occur before sending.

  • Read-only mode, job allowlists covering discovery and mutations, write-category controls, and JSONL auditing of allowed and refused calls.

  • Optional generic administrator REST request, disabled by default.

πŸ“¦ Published artifacts

ghcr.io/grglzrv/jenkins-mcp-server:<version>
ghcr.io/grglzrv/jenkins-mcp-server:<version>-minibridge
oci://ghcr.io/grglzrv/charts/jenkins-mcp-server --version <version>

Release images are published for linux/amd64 and linux/arm64. The plain image contains only the Python server. The -minibridge tag is a separately built variant that bundles both executables in one container; Minibridge is not a sidecar and is not downloaded at pod startup.

πŸ—οΈ Architecture

Requests pass through up to two independent enforcement layers before reaching Jenkins. The server's own policy always applies. The minibridge proxy is optional and adds a second layer in front of it.

Jenkins MCP Server architecture

Inside minibridge the three settings do different jobs, which is easy to confuse because they sit side by side in values.yaml:

Setting

Question it answers

Nature

minibridge.tools, minibridge.methodsDeny

Which tools and capabilities may be called at all?

Deterministic, by name

minibridge.guardrails

Is the content flowing through safe?

Heuristic, pattern matching

minibridge.policer

Which engine evaluates, and does a violation block or only log?

Engine configuration

minibridge is the component; guardrails is one key inside it. With minibridge.enabled: false the guardrails list does nothing, because there is no proxy to evaluate it.

The deployment path in the reference Kubernetes setup:

Hermes Agent
    β”‚ HTTPS over Tailscale
    β–Ό
Tailscale Kubernetes Ingress
    β”‚
    β–Ό
Jenkins MCP Server /mcp
    β”‚ HTTPS through Tailscale egress
    β–Ό
Jenkins controller

Hermes never receives the Jenkins API token. The token stays in a Kubernetes Secret or external secret provider and is used only by the MCP server.

🐳 Quick start with Docker

cp .env.example .env
# Configure Jenkins URL, LDAP-backed Jenkins user ID, API token, and CA bundle.

docker build --build-arg APP_VERSION=$(cat VERSION) \
  -t jenkins-mcp-server:$(cat VERSION) .

docker run --rm \
  --env-file .env \
  -p 8000:8000 \
  -p 8081:8081 \
  -v "$PWD/certs:/certs:ro" \
  jenkins-mcp-server:$(cat VERSION)

Or use the maintained Compose deployment, which applies a read-only root filesystem, dropped capabilities, writable temporary mounts, and an audit volume:

cp .env.example .env
# Edit .env, keep it out of source control, and restrict its permissions.
# Keep the documented uppercase variable names; settings names are case-sensitive.
docker compose up server

# Run the single-container Minibridge variant instead. Its sample policy
# allows every non-destructive tool and refuses @destructive.
docker compose --profile minibridge up minibridge

Do not start both services together because they publish the same MCP port.

Health endpoints:

GET http://localhost:8081/healthz
GET http://localhost:8081/readyz

MCP endpoint:

http://localhost:8000/mcp

☸️ Helm installation

For a production-shaped install, create the credentials Secret outside Helm and use the external-Jenkins example:

kubectl create namespace jenkins-mcp
kubectl -n jenkins-mcp create secret generic jenkins-mcp-secrets \
  --from-literal=JENKINS_USERNAME='<actual-jenkins-login-id>' \
  --from-literal=JENKINS_TOKEN='<JENKINS_API_TOKEN>'

helm upgrade --install jenkins-mcp \
  oci://ghcr.io/grglzrv/charts/jenkins-mcp-server \
  --version 2.10.17 \
  --namespace jenkins-mcp \
  --values examples/values/existing-secret.yaml \
  --set-string jenkins.url=https://jenkins.example.com

Replace the URL with the exact externally reachable Jenkins base URL, including any context path. The chart leaves NetworkPolicy disabled by default so an external controller protected by cluster/firewall allowlists remains reachable. Enable it only after modeling both MCP client ingress and Jenkins egress.

Credential-source rules, TLS/CA settings, NetworkPolicy, scaling, ingress, External Secrets, Tailscale, and the complete values reference live in the Helm chart guide. The examples index maps each supported deployment shape to a ready-to-edit values file or manifest.

The chart defaults preStopDelaySeconds to 5 so a terminating pod continues serving while EndpointSlice, Service proxy, ingress, and load-balancer state propagates. Set it to 0 to disable, or tune it from rollout measurements; it must remain below terminationGracePeriodSeconds because the hook and process shutdown share that total budget. Minibridge sessions are not migrated from a terminated pod, so affected clients must reconnect and initialize again.

πŸ”Œ Connecting a client

Transports

The MCP specification defines two transports, and this server implements both. Select with MCP_TRANSPORT or --transport.

The direct HTTP server runs in stateless mode: it does not retain MCP sessions between requests. MCP 2.2's idle-session timeout and concurrent-session cap do not apply to that endpoint. Minibridge manages its own sessions around the private stdio process; Python SDK HTTP session settings do not control them.

Transport

Value

Use for

Streamable HTTP

streamable-http (default)

Remote and containerised deployments. Serves POST and GET on one endpoint at mcp.path, upgrading to an SSE stream when a response streams

stdio

stdio

Running the server as a local subprocess of the client. No listener, no ports

With minibridge.enabled=true, clients still use Streamable HTTP at /mcp: minibridge.mode=http makes Minibridge own that public endpoint. Minibridge then runs Jenkins MCP Server over a private stdio pipe inside the same container, matching Acuvity's registry images. That internal hop is not a client transport, does not open a second listener, and adds no sidecar or adapter.

flowchart LR
    Client["MCP client"]
    subgraph Container["One container in the pod"]
        direction LR
        MiniBridge["Minibridge AIO"] -->|"private stdio pipe"| Server["Jenkins MCP Server"]
    end
    Jenkins["Jenkins"]
    Client -->|"Streamable HTTP /mcp"| MiniBridge
    Server -->|"HTTPS API"| Jenkins

HTTP+SSE as a separate transport, with its own /sse and /message endpoints, was deprecated in the 2025-03-26 revision and is not offered here. Streamable HTTP already streams over SSE within its single endpoint, which is what current clients expect. A client that only speaks the legacy transport needs an external compatibility bridge; the Minibridge deployment itself stays single-container and adds no adapter.

Endpoints

Point the client at the /mcp path of whichever address exposes it. The exact configuration keys differ per client, so use its own documentation for the surrounding structure.

Deployment

Endpoint

Helm chart, in-cluster

http://<release>-jenkins-mcp-server.<namespace>.svc.cluster.local:8000/mcp

Raw manifests, in-cluster

http://jenkins-mcp.jenkins-mcp.svc.cluster.local:8000/mcp

Behind an ingress

https://<ingress-host>/mcp

Every shipped Kubernetes MCP Service retains ClientIP affinity with a 600-second timeout. The direct HTTP server is stateless; affinity is needed for Minibridge's stateful sessions when using multiple replicas. For Minibridge, an ingress controller that bypasses Service load balancing or hides the original client address needs equivalent controller-specific affinity. Affinity cannot preserve Minibridge sessions when their owning pod restarts; clients must reconnect and initialize a new session.

The Helm chart derives the Service name from the release, so a release named jenkins-mcp in namespace jenkins-mcp gives jenkins-mcp-jenkins-mcp-server.jenkins-mcp.svc.cluster.local. Read it back rather than assuming:

kubectl -n <namespace> get svc -l app.kubernetes.io/name=jenkins-mcp-server \
  -o jsonpath='{.items[0].metadata.name}'

With an ingress, the controller assigns the hostname asynchronously:

kubectl -n <namespace> get ingress -l app.kubernetes.io/name=jenkins-mcp-server \
  -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}'

Whichever client you use, it never receives the Jenkins API token. The token stays in a Kubernetes Secret and is used only by this server.

For Hermes Agent specifically, mcp_servers is the correct top-level key and an HTTP server is selected by url; do not add a transport field. Start from deploy/hermes/mcp-config.yaml, or use mcp-config-in-cluster.yaml with the raw Kubernetes manifests. The optional timeout value is in seconds.

πŸ›‘οΈ Security and guardrails

Two independent layers. The server's own policy always applies; the minibridge proxy is optional and sits in front of it.

Runtime guardrails

Minibridge integration. Minibridge, developed by Acuvity, establishes secure agent-to-MCP connectivity, supports Rego and HTTP-based policy enforcement πŸ•΅οΈ, and simplifies orchestration. The -minibridge image bundles it with a Jenkins-aware Rego policy in a single container β€” no sidecar, nothing downloaded at startup.

In the default minibridge.mode=http, Minibridge serves MCP 2025-03-26 Streamable HTTP at mcp.path (default /mcp). The Jenkins process is its private stdio child, exactly like Acuvity's mcp-server-atlassian container; the Service and ingress expose only Minibridge.

The guardrails below follow the runtime security model Acuvity defines for their MCP server registry, with the policy itself written for Jenkins: it treats the script console, credential stores and $JENKINS_HOME as sensitive, and redacts Jenkins API tokens, crumbs and session cookies.

Guardrail

Summary

covert-instruction-detection

Detects hidden or obfuscated directives, including instructions planted in build logs

sensitive-pattern-detection

Flags the script console, credential stores, $JENKINS_HOME, secrets/master.key, traversal and cloud metadata endpoints

shadowing-pattern-detection

Identifies tool descriptions that override or redirect other tools

schema-misuse-prevention

Rejects out-of-schema arguments used to smuggle instructions

cross-origin-tool-access

Blocks references to tools outside this server

secrets-redaction

Redacts Jenkins API tokens, crumbs, session cookies, and complete PEM private-key blocks from responses

basic authentication

Optional shared secret restricting which clients may reach the server

Each is enabled individually, so only the protections your environment needs are active. Tool policy is separate: deny by name or by group, and denied tools are removed from discovery as well as refused on call.

Hardened by default

Property

Detail

Non-root, least privilege

uid 10001, all capabilities dropped, no privilege escalation, RuntimeDefault seccomp

Immutable runtime

Read-only root filesystem with explicit writable mounts

Irreversible actions opt-in

The master destructive switch, job deletion, and administrator requests are off by default; job paths are a glob allowlist and traversal segments are rejected

Version pinning

Minibridge pinned to a release archive and checksum-verified at build

SBOM and provenance

Attestations published for every image and release asset

Continuous scanning

CodeQL, pip-audit and dependency review on every change

Verified, not asserted

Every tool is exercised against four Jenkins LTS lines in CI, and the chart is installed into real k3s clusters across four Kubernetes versions β€” install, upgrade, helm test, uninstall. A probe speaks MCP through the proxy and asserts denied tools are absent from tools/list and refused on call.

The Jenkins account remains the outer boundary: these controls only narrow what that account can already do.

Server policy β€” always enforced

Applied in-process, so it holds whether or not the proxy is deployed.

Setting

Default

Effect

mcp.allowedJobs

AI/*,Platform/*

Glob allowlist for job reads, discovery, builds, and mutations. Queue cancellation resolves the owning job before authorization; traversal segments are rejected

mcp.redactParameterPatterns

[]

Additional case-insensitive globs for build parameter names whose values get_build_info redacts; built-in secret detection remains active

mcp.readOnly

false

Refuses every write tool

mcp.allowDestructive

false

Master gate for job updates/deletes, build stops, queue cancellation, and node offlining

mcp.allowJobDelete

false

delete_job is opt-in; deletion is irreversible

mcp.allowAdminRequest

false

jenkins_admin_request is opt-in

mcp.allowNodeWrite

false

set_node_offline; taking a node offline also needs allowDestructive, while bringing it online does not

Jenkins permissions remain the outer boundary: these settings can only narrow what the account is already allowed to do.

minibridge proxy β€” optional

Enabled with minibridge.enabled=true, which selects the -minibridge image. It filters tools before they reach the server and inspects content in both directions.

Tool policy accepts individual names or these groups:

Group

Tools

@read

list_jobs, get_job, get_job_config, get_build_info, get_build_console, list_running_builds, get_queue, get_queue_item, list_nodes, get_node

@write

create_job_from_xml, copy_job, enable_job, disable_job, create_pipeline_job, create_multibranch_pipeline, scan_multibranch_pipeline, trigger_build

@destructive

update_job_config, delete_job, stop_build, cancel_queue_item, set_node_offline

@admin

jenkins_admin_request

@all

every tool

minibridge:
  enabled: true
  tools:
    deny: ["@destructive", "@admin"]   # denied tools are hidden and refused

Content guardrails are listed at the top of this file and configured under minibridge.guardrails. All are off by default; enable only what the environment needs.

Threat model, required production controls, secret handling and the known limitations are in SECURITY.md.

🩺 Troubleshooting

Start with the workload and /readyz; readiness validates local configuration but deliberately does not call Jenkins. A ready pod can still be blocked by DNS, firewall rules, NetworkPolicy, TLS, a proxy/SSO redirect, credentials, or Jenkins permissions.

The troubleshooting guide has the diagnostic commands and symptom-to-fix table. Jenkins versions, plugins, CSRF, and least-privilege permissions are covered in the compatibility guide.

πŸ› οΈ Development

make install
make lint
make coverage
make verify-version

With Helm installed:

make helm-lint
make helm-template

Full Docker-based Jenkins TLS integration test:

make integration

🏷️ Releases and versioning

One semantic version covers the Python package, the image and the chart. The chart pins no image tag of its own:

image:
  repository: ghcr.io/grglzrv/jenkins-mcp-server
  tag: ""        # empty means use Chart.appVersion

Chart.appVersion is the image tag, so a chart version identifies exactly one application build. Chart-only changes therefore still take a full version bump β€” the trade for that guarantee.

To cut a release: complete every [Unreleased] category in CHANGELOG.md, then

NEW_VERSION=2.10.17
make version VERSION="$NEW_VERSION"   # promotes the notes, rewrites every version pin

Commit, open a pull request, and merge once the checks pass. Merging publishes automatically; no manual tag is needed. The workflow refuses to publish unless the requested version matches VERSION, every pin agrees, the release notes are complete, and release-impacting changes carry a strictly newer version.

Published per release:

ghcr.io/grglzrv/jenkins-mcp-server:<version>       # also <major>.<minor>, <major>, latest
ghcr.io/grglzrv/jenkins-mcp-server:<version>-minibridge
oci://ghcr.io/grglzrv/charts/jenkins-mcp-server --version <version>

Every push to main also publishes :edge, which the chart never references; opt in with image.tag: edge.

Full procedure, script reference and review checklist: docs/releasing/RELEASE.md.

πŸ“š Documentation

πŸ“„ Licence and attribution

Released under the MIT Licence β€” see LICENSE. That covers this repository only. The -minibridge image additionally bundles Minibridge by Acuvity, under Apache 2.0, alongside its base image's own packages; docker/Dockerfile.minibridge pins the exact Minibridge source commit, verifies its checksum, and applies the repository's documented compatibility backports before building it. The guardrail model this project's Rego policy follows also originates with Acuvity's MCP server registry.

This is an independent project, not affiliated with or endorsed by the Jenkins project or the Continuous Delivery Foundation. Jenkins is a registered trademark of the Continuous Delivery Foundation.

Available Tools

24 tools
cancel_queue_itemA

Remove a queued item before it starts.

Destructive: the request to build is discarded. Takes the queue item id from get_queue, which is not a build number. Use stop_build for a build that is already running. Requires MCP_ALLOW_BUILD_WRITE, MCP_ALLOW_DESTRUCTIVE and MCP_ALLOW_BUILD_STOP.

Inputs: item_id (required).

copy_jobA

Copy an existing job's configuration to a new name.

The target inherits the source's settings, including its enabled or disabled state; build history and workspaces are not copied. Both source and target must be inside MCP_ALLOWED_JOBS. Jenkins requires Job/ExtendedRead on the source and Job/Create on the target parent; it also requires source Job/Configure when extended-read redacts secrets.

Inputs: source_job (required), target_job (required).

create_job_from_xmlA

Create a job from a raw config.xml.

Fails if the name already exists. Prefer create_pipeline_job or create_multibranch_pipeline unless you need full control of the XML. Do not place plaintext credentials in the XML; reference Jenkins-managed credential IDs. The encoded body must fit MCP_MAX_REQUEST_BYTES.

Inputs: job_name (required), config_xml (required).

create_multibranch_pipelineA

Create a multibranch Pipeline that discovers branches from a Git repository.

Requires the workflow-multibranch, branch-api and git plugins. Run scan_multibranch_pipeline afterwards to populate branches immediately. repository_url must not contain embedded credentials, a query string, or a fragment. credentials_id names a credential already stored in Jenkins; never pass a token, password or private key in that field. script_path must be a canonical repository-relative path. The generated XML must fit MCP_MAX_REQUEST_BYTES.

Inputs: job_name (required), repository_url (required), description, script_path, +1 more.

create_pipeline_jobA

Create a Pipeline job from an inline Jenkinsfile.

The script runs in the Groovy sandbox. Requires workflow-job and workflow-cps, both included in the workflow-aggregator plugin. Reference Jenkins credential IDs; do not put plaintext secrets in the Jenkinsfile. The generated XML must fit MCP_MAX_REQUEST_BYTES.

Inputs: job_name (required), jenkinsfile (required), description.

delete_jobA

Delete a job and all of its build history.

Destructive and irreversible through this server: Jenkins core removes the job and its builds, so recovery requires an external backup. Disabled by default; requires MCP_ALLOW_JOB_WRITE, MCP_ALLOW_DESTRUCTIVE and MCP_ALLOW_JOB_DELETE. Confirm with get_job first.

Inputs: job_name (required).

disable_jobA

Disable a job so Jenkins stops building it.

Queued builds are not cancelled; use cancel_queue_item for those. The job and its history are kept, so this is reversible with enable_job.

Inputs: job_name (required).

enable_jobB

Enable a job so Jenkins will build it. Safe to call when already enabled.

Inputs: job_name (required).

get_build_consoleA

Read a build's console output.

Output is truncated to MCP_MAX_LOG_BYTES; pass the returned next_start back as start to continue reading, which is how a running build is followed. build_number accepts a number or an alias such as lastBuild. Invalid or incomplete Jenkins pagination metadata is refused rather than guessed.

Inputs: job_name (required), start, build_number.

get_build_infoA

Get one build's result, timing, duration and parameters.

build_number accepts a number or an alias such as lastBuild, lastSuccessfulBuild or lastFailedBuild. Secret-like parameter names and password/token/credential parameter classes have redacted values. Complex plugin parameter values and unrelated action/change-set payloads are not returned.

Inputs: job_name (required), build_number.

get_jobA

Get one job's current state: description, buildable flag, health and the most recent build references. Use get_job_config for its XML definition, or get_build_info for a specific build. Plugin actions and upstream/downstream job objects are not returned.

Inputs: job_name (required).

get_job_configA

Fetch a job's config.xml definition.

Requires Job/ExtendedRead in Jenkins; Job/Read alone is not enough and fails with 403 while other tools keep working.

Inputs: job_name (required). Returns: result

get_nodeA

Get one node's capacity, idle state and offline reason.

Current-build details are intentionally excluded; use list_running_builds for running jobs filtered through MCP_ALLOWED_JOBS. Node names are case sensitive and must not be empty.

Inputs: node_name (required).

get_queueA

List builds waiting to start, with why each is blocked.

A queue item is not a build yet and has no build number; it gains one when an executor picks it up. Items outside MCP_ALLOWED_JOBS are omitted. Queue actions and build-parameter values are not returned.

Inputs: no named parameters.

get_queue_itemA

Follow one queued build from trigger to executor assignment.

Pass queue_id from trigger_build. While waiting, the response explains why the item is blocked; once Jenkins starts it, executable contains the build number and URL needed by get_build_info. The owning job must match MCP_ALLOWED_JOBS. Jenkins retains completed queue records only briefly.

Inputs: item_id (required).

jenkins_admin_requestA

Send an arbitrary authenticated request to a Jenkins path.

A powerful escape hatch for endpoints no other tool covers, disabled by default and requiring MCP_ALLOW_ADMIN_REQUEST. MCP_ALLOWED_JOBS still applies to job URLs. The Groovy console additionally requires MCP_ALLOW_SCRIPT_CONSOLE and remains blocked by Minibridge when its sensitive-pattern guardrail is active. Non-read methods can mutate or delete Jenkins state and are not gated by MCP_ALLOW_DESTRUCTIVE; confirm the exact method, path and body first. path must be Jenkins-relative and absolute, for example /api/json. Session and CSRF headers are withheld from the response. Unlike typed mutation tools, raw 3xx responses are returned for the caller to interpret. The encoded body must fit MCP_MAX_REQUEST_BYTES.

Inputs: path (required), method (required), body, content_type.

list_jobsA

List jobs visible to this server, optionally within a folder.

Returns name, full path, URL and build colour. Pass a folder's full name, for example "Platform", to list its immediate children. Jobs outside MCP_ALLOWED_JOBS are omitted rather than reported as errors. Arbitrary plugin action/property payloads are not returned.

Inputs: folder.

list_nodesA

List build nodes with their capacity, idle and offline state.

Executor/current-build details are intentionally excluded; use list_running_builds for running jobs filtered through MCP_ALLOWED_JOBS.

Inputs: no named parameters.

list_running_buildsA

List builds currently executing across the controller, with their job and build number. Jobs outside MCP_ALLOWED_JOBS are omitted. Use get_build_console to follow one. Plugin-specific executor/action payloads are not returned.

Inputs: no named parameters.

scan_multibranch_pipelineA

Trigger a branch scan on a multibranch Pipeline so newly pushed branches are discovered without waiting for the next scheduled scan.

Inputs: job_name (required).

set_node_offlineA

Take a node offline, or bring it back online.

Taking a node offline is destructive: running builds keep going but no new work is scheduled there, which can stall a pipeline. Requires MCP_ALLOW_NODE_WRITE, and taking offline additionally requires MCP_ALLOW_DESTRUCTIVE.

Inputs: offline (required), node_name (required), message.

stop_buildA

Stop a running build.

Destructive: the build is abandoned and marked ABORTED, and any work it had done is lost. mode escalates from stop to term and then kill. Freestyle builds support only stop; term and kill are Pipeline-only and require workflow-job. Requires MCP_ALLOW_BUILD_WRITE, MCP_ALLOW_DESTRUCTIVE and MCP_ALLOW_BUILD_STOP.

Inputs: job_name (required), build_number (required), mode.

trigger_buildA

Queue a build.

Returns a validated queue_id and a canonical queue_url built from configured JENKINS_URL, not a build number: the build has not started yet. Poll get_queue_item until its executable has a number, then use get_build_info. For a parameterised job pass parameters, using an empty object to accept every default; omitting it entirely makes Jenkins reject the trigger. Their encoded form must fit MCP_MAX_REQUEST_BYTES.

Inputs: job_name (required), parameters.

update_job_configA

Replace a job's config.xml in full.

Destructive: the previous definition is overwritten with no history kept by this server, and any setting absent from the XML you supply is lost. Read the current config first with get_job_config, and do not place plaintext credentials in the XML. Requires MCP_ALLOW_JOB_WRITE, MCP_ALLOW_DESTRUCTIVE and MCP_ALLOW_JOB_UPDATE. The encoded body must fit MCP_MAX_REQUEST_BYTES.

Inputs: job_name (required), config_xml (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 24 tools

    Disambiguation5/5

    Each tool targets a distinct resource+action, and where overlaps exist (create_job_from_xml vs create_pipeline_job vs create_multibranch_pipeline, get_queue vs get_queue_item, get_build_info vs get_build_console) the descriptions explicitly state when to use which. No two tools appear interchangeable.

    Naming Consistency5/5

    Consistent snake_case verb_noun pattern throughout (list_jobs, get_job, delete_job, trigger_build, stop_build, get_queue_item, set_node_offline). The single jenkins_admin_request deviates slightly but remains readable and clearly scoped.

    Tool Count4/5

    At 24 tools this is on the heavier side, but the Jenkins domain is broad (jobs, builds, queue, nodes, admin) and each tool covers a genuinely distinct operation, so nothing feels redundant. Slightly high for a single server, though every tool earns its place.

    Completeness4/5

    Strong lifecycle coverage: job CRUD/config, pipeline creation, build trigger/stop/info/console, queue inspection and cancellation, nodes, plus an admin escape hatch for anything else. Minor gaps remain (e.g. build artifacts, credential listing, views), but the admin tool largely backstops them.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      A Model Context Protocol (MCP) server that enables AI tools like chatbots to interact with and control Jenkins, allowing users to trigger jobs, check build statuses, and perform other Jenkins operations through natural language.
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      A server that enables interaction with Jenkins CI/CD pipelines from any compatible MCP client (like Claude Desktop), allowing users to manage jobs, builds, coverage reports, and other Jenkins functionality through natural language.
      11
      15 npm
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server for interacting with a Jenkins CI/CD server. Allows you to trigger jobs, check build statuses, and manage your Jenkins instance through MCP.
      46 npm
      14
      Apache 2.0