Jenkins MCP Server
Use it as a secure MCP server to inspect and manage Jenkins jobs, builds, queues, and nodes through 24 tools, with destructive/admin actions disabled by default.
List/read jobs, job configs, build details, console logs, running builds, queue items, and nodes.
Create, copy, enable/disable jobs; create Pipeline and multibranch Pipeline jobs; scan multibranch projects; trigger parameterized builds.
Perform opt-in destructive actions: update job configs, delete jobs, stop builds, cancel queued items, and take nodes offline/online.
Use an opt-in generic Jenkins REST admin request as a powerful escape hatch.
Connect over Streamable HTTP
/mcpor stdio, optionally behind Minibridge with allowlists, guardrails, redaction, read-only mode, and auditing.
Provides tools for managing Jenkins jobs, builds, nodes, queues, and pipelines, including creating, updating, deleting, triggering builds, and retrieving console logs.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Jenkins MCP Server What's the status of the last build of the 'my-service' job?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.
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:
Clone this repository to the machine you operate on.
Open ONBOARDING.md, a phased installer written for you.
Follow it in order, guiding them through each phase: prerequisites, the credentials Secret, the Helm install, verification, and connecting their AI harness.
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
Let your agent do it. Point your agent at this repository and at ONBOARDING.md. It installs the server step by step, pausing for every secret and every state change.
By hand. Follow Quick start with Docker or Helm installation below.
Related MCP server: MCP-Jenkins
π§° Tools
24 tools, grouped as the guardrail policy groups them.
Group | Tool | Purpose |
|
| List jobs, optionally within a folder |
|
| Projected job state and recent build references |
|
| Fetch |
|
| Projected build result, duration, redacted parameters |
|
| Progressive, size-bounded console log |
|
| Builds currently executing |
|
| Inspect the build queue |
|
| Follow a queue ID until Jenkins assigns a build number |
|
| List agent status without executor/job details |
|
| Agent status without executor/job details |
|
| Create a job from |
|
| Create a Pipeline job |
|
| Create a Git multibranch Pipeline |
|
| Trigger a branch scan |
|
| Copy an existing job |
|
| Enable a job |
|
| Disable a job |
|
| Trigger a build, with parameters |
|
| Overwrite an existing |
|
| Delete a job β irreversible, opt-in |
|
| Stop, terminate, or kill a running build |
|
| Cancel a queued item |
|
| Take an agent offline; bringing it online only needs node-write permission |
|
| 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 |
| Any job path containing |
| Pipeline tools, and the |
| Multibranch tools |
βοΈ Capabilities
Native MCP Streamable HTTP endpoint at
/mcpand 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.
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 |
| Which tools and capabilities may be called at all? | Deterministic, by name |
| Is the content flowing through safe? | Heuristic, pattern matching |
| 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 controllerHermes 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 minibridgeDo not start both services together because they publish the same MCP port.
Health endpoints:
GET http://localhost:8081/healthz
GET http://localhost:8081/readyzMCP 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.comReplace 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 |
| Remote and containerised deployments. Serves |
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"| JenkinsHTTP+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 |
|
Raw manifests, in-cluster |
|
Behind an ingress |
|
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 |
| Detects hidden or obfuscated directives, including instructions planted in build logs |
| Flags the script console, credential stores, |
| Identifies tool descriptions that override or redirect other tools |
| Rejects out-of-schema arguments used to smuggle instructions |
| Blocks references to tools outside this server |
| Redacts Jenkins API tokens, crumbs, session cookies, and complete PEM private-key blocks from responses |
| 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, |
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, |
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 |
|
| Glob allowlist for job reads, discovery, builds, and mutations. Queue cancellation resolves the owning job before authorization; traversal segments are rejected |
|
| Additional case-insensitive globs for build parameter names whose values |
|
| Refuses every write tool |
|
| Master gate for job updates/deletes, build stops, queue cancellation, and node offlining |
|
|
|
|
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
| every tool |
minibridge:
enabled: true
tools:
deny: ["@destructive", "@admin"] # denied tools are hidden and refusedContent 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-versionWith Helm installed:
make helm-lint
make helm-templateFull 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.appVersionChart.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 pinCommit, 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 toolscancel_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
Scored across 24 tools
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.
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.
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.
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
Related MCP Connectors
The MCP server for Azure DevOps, bringing the power of Azure DevOps directly to your agents.
One MCP server for all your MCP servers: code mode, per-tool permissions, approvals and audit.
MCP server for generating rough-draft project plans from natural-language prompts.
MCP Server for JFrog, providing tools for development and artifact management.
Related MCP Servers
- AlicenseNot gradedqualityNot gradedmaintenanceA 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
- AlicenseBqualityCmaintenanceA 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.1115 npmMIT
- AlicenseNot gradedqualityDmaintenanceAn 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 npm14Apache 2.0
- AlicenseNot gradedqualityBmaintenanceMCP server for Jenkins to inspect builds, control jobs, and manage pipeline configuration.47 npmMIT