Develocity MCP server: two endpoints, self-hosted

Why there are two tool sets on two endpoints, why Gradle insists the analytics credential be read-only and separate, and why you cannot even list the tools without a key.

Last verified 25 August 2026 · from docs.develocity.ai 2026.2, installation and AI clients pages

This page is one of 90 in a directory of monitoring and developer tools. Each page checks what an AI coding agent can get out of the tool through its MCP server, the connector that lets the agent query the tool directly.

What is the Gradle Develocity MCP server?

Develocity records what your builds actually did: how long each task took, which tests failed, whether the cache hit, and what the exception was. It covers Gradle, Maven, sbt, Bazel, npm and Python builds.

The MCP server turns that record into something an agent can query. The stated use is investigating a build failure without leaving the editor, and comparing two builds to work out why the cache missed.

Both tool sets bundle skills: guided workflows that activate automatically to steer the client toward effective queries. Gradle describes them the same way for the build tools and the analytics tools.

Two tool sets, two endpoints, two version floors:

Either set works alone. Gradle notes that some data, including test results and failure groups, comes only from the Develocity tools.

Develocity owns the build, and stops there.

For an agent, Develocity answers why the build broke and why it was slow. The organization-wide version of both questions sits behind the analytics set. It knows nothing about the source of the change or what happened after it shipped.

What can an AI agent do with Gradle Develocity?

There are two tool sets on two endpoints, and neither publishes a count. The Develocity tools cover individual builds: exceptions, stack traces, test outcomes and cache performance. The Analytics tools cover the organization: dependency risk, performance trends and CI stability. /mcp on the Develocity instance serves the build tools, and the analytics tools too when Athena Data Export is on. /drv-mcp serves analytics alone.

Gradle Develocity MCP server limits: where answers come back incomplete

You cannot list the tools without a key. That boundary comes first, because it stops an evaluation before you can size the connector.

How to configure Gradle Develocity MCP for agents

1. 1

   Enable the pod

   mcpServer.enabled: true in values.yaml, then confirm with kubectl get pods -l app.kubernetes.io/component=mcp-server.

2. 2

   Decide whether you need analytics at all

   One set works without the other, and the analytics half carries the whole Athena prerequisite chain.

3. 3

   Create a second AWS credential if you do

   Gradle states that the Athena credentials used by the MCP server cannot be the ones used by Athena Data Export, and must be read-only.

4. 4

   Issue an access key with the right permission

   It must carry Access build data via the API and MCP, and it is checked on every request.

5. 5

   Plan for Claude Desktop separately

   Gradle documents that it cannot send an access key header and needs a local proxy.

Paste this into your agent’s instructions

Two tool sets answer at two different scopes, and a build-level answer and an organization-level answer look alike once the agent writes them as prose.

When you answer using Develocity MCP tools, state:
- Whether the answer came from the Develocity tools, which
  see individual builds, or the Analytics tools, which see
  aggregate data across the organization.
- The build scan or the time window the numbers cover.
- That test results and failure groups come only from the
  Develocity tools, so an analytics-only setup cannot see
  them.
Never state that data does not exist. State which tool set
you queried and what it returned.
Write your answer in ASD-STE100 Simplified Technical
English. Use short sentences with one idea in each.

Do you need the MCP server at all?

Not when you already know which build broke. A build scan URL in a browser remains the direct route then, and it is what the tools are reading behind the scenes.

The Develocity API is the direct path for anything scheduled, and it takes the same access key.

For flaky tests specifically, BuildPulse and Allure TestOps both connect over their own servers.

For the CI system rather than the build, Jenkins and CircleCI answer questions about the pipeline that Develocity does not model.

With MCP, failure grouping and build comparison arrive as tool results rather than as a page to read, which is the difference when the question is why two builds diverged.

Enable /mcp first. Add /drv-mcp only when the question is about the whole organization.

Gradle Develocity MCP server setup

The server runs inside your own Develocity deployment. Enable it with mcpServer.enabled: true in your Helm values, then confirm the pod is running.

Every block below carries a Develocity access key as a bearer token. The key needs the Access build data via the API and MCP permission, and Gradle states it is required for every interaction, including initialize and listing the tools.

Substitute your own Develocity host for develocity.example.com. Reporting Kit deployments add a second entry pointing at /drv-mcp on the Reporting Kit host.

claude mcp add --transport http develocity --scope user \
  https://develocity.example.com/mcp \
  --header "Authorization: Bearer <access-key>"

kubectl get pods --namespace develocity \
  -l app.kubernetes.io/component=mcp-server

curl -X POST https://develocity.example.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer <access-key>" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",
       "params":{"protocolVersion":"2025-03-26",
       "capabilities":{},"clientInfo":{
       "name":"curl-client","version":"1.0.0"}}}'

{"mcpServers":{"develocity":{"type":"http",
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

[mcp_servers.develocity]
url = "https://develocity.example.com/mcp"

[mcp_servers.develocity.headers]
Authorization = "Bearer <access-key>"

Every other client

Each block below is the configuration for one client, with the file path and the key that client expects.

{"mcpServers":{"develocity":{"command":"npx",
  "args":["-y","mcp-remote",
    "https://develocity.example.com/mcp",
    "--header","Authorization: Bearer ${API_ACCESS_TOKEN}",
    "--transport","http-only"],
  "env":{"API_ACCESS_TOKEN":"<access-key>"}}}}

{"inputs":[{"type":"promptString",
  "id":"develocity-access-key",
  "description":"Develocity Access Key","password":true}],
 "servers":{"develocity":{"type":"http",
  "url":"https://develocity.example.com/mcp",
  "headers":{"Authorization":
    "Bearer ${input:develocity-access-key}"}}}}

{"mcpServers":{"develocity":{
  "httpUrl":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

claude mcp add --transport http develocity-analytics \
  --scope user https://reporting-kit.example.com/drv-mcp \
  --header "Authorization: Bearer <access-key>"

{"mcpServers":{"develocity":{
  "httpUrl":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

{"mcpServers":{"develocity":{"serverUrl":
  "https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

{"context_servers":{"develocity":{
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

{"mcpServers":{"develocity":{"type":"http",
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

{"amp.mcpServers":{"develocity":{
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

{"mcpServers":{"develocity":{
  "type":"streamableHttp",
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

extensions:
  develocity:
    type: streamable_http
    uri: https://develocity.example.com/mcp
    headers:
      Authorization: Bearer <access-key>

{"mcpServers":{"develocity":{"command":"npx",
  "args":["-y","mcp-remote",
    "https://develocity.example.com/mcp",
    "--header","Authorization: Bearer ${API_ACCESS_TOKEN}",
    "--transport","http-only"],
  "env":{"API_ACCESS_TOKEN":"<access-key>"}}}}

{"mcpServers":{"develocity":{
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

{"mcpServers":{"develocity":{"type":"http",
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

{"mcpServers":{"develocity":{
  "type":"streamable-http",
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

name: Develocity
version: 0.0.1
schema: v1
mcpServers:
  - name: develocity
    type: streamable-http
    url: https://develocity.example.com/mcp
    requestOptions:
      headers:
        Authorization: Bearer <access-key>

{"mcpServers":{"develocity":{
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

{"mcpServers":{"develocity":{"type":"http",
  "url":"https://develocity.example.com/mcp",
  "headers":{
    "Authorization":"Bearer <access-key>"}}}}

Read-only access, permissions and security

• The key is checked on every call

  Gradle states that the access key with the Access build data via the API and MCP permission is required for every interaction, including initialize and listing the available tools. Nothing is readable before authentication.

• The analytics credential must be separate and read-only

  Gradle states plainly that for security reasons the Athena credentials used by the MCP server cannot be the same as those used by Athena Data Export.

• The IAM policy is narrower than it looks

  It includes PutObject and DeleteObject, and Gradle warns those must apply only to the S3 bucket holding Athena query results, never the bucket holding the build model data.

• Build data carries source detail

  Exception messages, stack traces and task names describe your codebase, and they are what these tools return.

• The proxy is third-party

  Gradle documents mcp-remote for Claude Desktop and states it is not affiliated with the project, asking you to check it against your own policy first.

Troubleshooting

Listing the tools returns an error

The access key is required for that call too. Gradle documents that every interaction, including initialize and listing the tools, needs a key with the Access build data via the API and MCP permission.

The pod is not there

The server is off by default. Set mcpServer.enabled: true in values.yaml, then check with kubectl get pods -l app.kubernetes.io/component=mcp-server.

Claude Desktop will not connect

Documented. Claude Desktop cannot send an access key header, and Gradle's own answer is a local mcp-remote proxy with --transport http-only.

The analytics tools are missing

They need Develocity 2025.4 or higher with Athena Data Export enabled, or Reporting Kit 2.1 or higher. Running them inside the Develocity MCP server needs 2026.2.0.

Test results are not available

An analytics-only setup cannot see them. Gradle states that some data, including test results and failure groups, comes only from the Develocity tools.

Athena queries fail with a permission error

Check which bucket the write permissions cover. The read-only role needs PutObject on the query results bucket only, and read access on the exported build model data.

Gradle Develocity MCP server: Reference

What the vendor documents

Public discussion of this connector is thin, and no tool count is published. The facts below are the ones Gradle states in its own installation documentation.

“The Develocity MCP Server requires an access key with the Access build data via the API and MCP permission for every interaction, including the initialize request and listing the available tools.”

“For security reasons, the Athena credentials used by the MCP Server cannot be the same as the ones used by the Athena Data Export feature. The credentials used by the MCP Server must be read-only.”

“Gradle isn't affiliated with or involved in the development of mcp-remote. Please ensure that any third-party software you install complies with your organization's security policies.”

The 2026.2 documentation was read on 25 August 2026, across the MCP servers overview, the installation manual and the AI clients page. No tool count appears in any of them, and the endpoint cannot be queried without a key, so none is claimed on this page.

Should you connect an agent to Gradle Develocity?

Yes. Best for build failure investigation on /mcp, with analytics added only when the question is organization-wide.

Strongest fit

Develocity operators who want an agent explaining a failed or slow build without leaving the editor.

Main advantage

It runs inside your own deployment, so build data never leaves your infrastructure to reach the model's tools.

Main weakness

The tool inventory is not published and cannot be listed without a key, so the connector cannot be sized before it is deployed.

Operational risk

An over-broad Athena role. The published policy template includes write actions that must be scoped to the query results bucket alone.

Frequently asked questions