All servers / Developer / Renovate MCP server
Renovate MCP server
MCP server for designing Renovate configurations interactively.
Tested by ConnectATDScore 90 out of 100. Tested 2026-11-19 on package version 2.1.2. Package: renovate-mcp · source
Score breakdown
| Runs | 18 / 20 | |
|---|---|---|
| Tool descriptions | 20 / 20 | |
| Package safety | 20 / 20 | |
| Maintenance | 20 / 20 | |
| Adoption | 12 / 20 |
What we saw
- Starts and answers the MCP handshake: yes (34.3 seconds including download)
- Tools offered: 19
- Last published: 2026-11-18
- Weekly downloads (npm): 1,006
- License: MIT · Direct dependencies: 10
Want this server set up for your team?
ConnectATD builds AI automation and wires up MCP servers like this one. Tell us what you are trying to do.
Talk to ConnectATDTools and how they are described
Agents choose tools from these descriptions. Under each name you can see how many of its parameters are explained.
check_setup1 of 1 parameter describedReport whether the Renovate CLI and config validator are reachable, their versions, and any env overrides in effect. Pass an optional `repoPath` to also diagnose the target repo's environment: parses the `.git/config` origin remote, reads any `endpoint`/`platform` in the repo's renovate config, probes endpoint reachability (using the same `https://`-only public-host allowlist as `dry_run`), and cross-references all three with token presence — surfaces actionable hints like 'set GITHUB_TOKEN before running dry_run'. The probe sends no credentials. Call this first when other tools fail with a spawn error or unexpected validation output.
read_config1 of 1 parameter describedLocate and parse the Renovate configuration in a repository. Searches, in Renovate's own priority order, for renovate.json(|c|5), .github/renovate.json(|c|5), .gitlab/renovate.json(|c|5), .renovaterc, .renovaterc.json(|c|5), and finally the 'renovate' field of package.json.
resolve_config5 of 5 parameters describedExpand every preset referenced by `extends` and return the fully resolved config. Built-in presets resolve offline against the committed catalogue. Pass `externalPresets: true` to fetch `github>`, `gitlab>`, `gitea>`, and `forgejo>` presets over HTTPS; like Renovate, each always goes to its public host (api.github.com, gitlab.com, gitea.com, code.forgejo.org). Presets on GitHub Enterprise, a self-hosted GitLab / Gitea / Forgejo, or Bitbucket Cloud are `local>` presets: pass `platform` (and `endpoint`, the API base URL, e.g. `https://gitlab.example.com/api/v4`), or set `RENOVATE_PLATFORM` / `RENOVATE_ENDPOINT` on the server, and `local>owner/repo` is fetched from there. `endpoint` routes nothing else. Renovate has no `bitbucket>` prefix, so that spelling is refused with a pointer at `local>`. npm presets are structurally unsupported and remain in `presetsUnresolved` regardless. Tokens are host-scoped: `GITHUB_TOKEN` / `GITLAB_TOKEN` / `GITEA_TOKEN` / `FORGEJO_TOKEN` / `BITBUCKET_TOKEN` each go only to their own platform's public host, `GITHUB_COM_TOKEN` to github.com, `RENOVATE_MCP_HOST_TOKENS` entries to their `matchHost`, and `RENOVATE_TOKEN` only to the home host named by the server env: `RENOVATE_PLATFORM`, at `RENOVATE_ENDPOINT` when set (there it wins over the platform's own token, which moves to that host as the fallback); without `RENOVATE_PLATFORM` `RENOVATE_TOKEN` is not sent. The `platform` / `endpoint` inputs route `local>` but never bind a token: a self-hosted endpoint passed only on the call gets one only from a `RENOVATE_MCP_HOST_TOKENS` entry. Where several tokens match a host, the longest matching host wins, as in Renovate's hostRules. A malformed `RENOVATE_MCP_HOST_TOKENS` is an error when fetching. Pass either `repoPath` (reads the repo's config) or `configContent` (an inline config object). The response includes `mergeQuality` (`"faithful"` — presets are merged with Renovate's own mergeChildConfig in a worker thread; `"preview"` only if that worker was unavailable and a simplified in-process merge was used) plus a `disclaimer` and a `warnings` array. Handlebars expressions other than `{{argN}}` are left verbatim; run `dry_run` for full config resolution.
explain_config5 of 5 parameters describedInverse of resolve_config: walk the same preset tree, but annotate every leaf field with the chain of presets that touched it. Each leaf in `explanation` carries `{ value, setBy }` where `setBy` lists every contribution in merge order — last entry wins for scalars and overwritten (non-mergeable) arrays; for mergeable arrays each entry adds its own slice. The `<own>` source means the value came from the user's input config (siblings of `extends`); other sources are preset references as written in `extends`. Use this to trace surprises like "why is `prCreation` set to 'not-pending'?". Pure analysis: same offline-by-default behaviour as resolve_config, plus the same `externalPresets` / `endpoint` / `platform` opt-ins. Pass `repoPath` (reads the repo's config) or `configContent` (an inline config). For full-fidelity output, run dry_run instead.
resolve_config_diff5 of 5 parameters describedCompute a structural diff between two *fully-resolved* Renovate configs — the `before` and `after` of a config refactor — entirely offline. This is the resolve-level counterpart to `dry_run_diff`: where `dry_run_diff` shows how the *proposed PRs* change (and collapses to a vacuous 0-vs-0 when the environment can't reach registries), this answers "does the new config produce the same effective settings as the old one, modulo the intended changes?". Each side accepts `repoPath` (locates the repo's config) OR `configContent` (an inline config object); both sides are resolved with `resolve_config`'s preset expansion + faithful merge. Non-array top-level keys are deep-compared and reported with before/after values; array-valued top-level keys (`packageRules`, `customManagers`, `matchManagers`, …) get an order-insensitive set diff (members only in `before` are `removed`, only in `after` are `added` — a tweaked rule shows as one of each). Shared `externalPresets` / `endpoint` / `platform` knobs apply to both sides. Returns a structured diff (`summary`, `fieldChanges`, `arrayChanges`) plus a human-readable `text` rendering and per-side `resolution` metadata (`mergeQuality`, `presetsUnresolved`, `warnings`).
suggest_presets9 of 9 parameters describedSearch Renovate presets by intent — fast, offline, no `renovate` invocation, no network. Given a free-text goal (e.g. "automerge patch and minor updates and group my dev dependencies"), it ranks matching presets from the committed built-in catalogue and, optionally, a local presets repo you point at. When no strong match exists it also sketches an unvalidated draft config from recognized intent. Returns: - `builtIn` / `local`: ranked matches `{ name, namespace, description, score, matchedOn, body? }`. Scoring is lexical (field-weighted name>namespace>description>body, with IDF rarity weighting so ubiquitous tokens like "group" don't drown specific matches) — a recall aid, not a stemmed search engine. - `coverage` (strong | partial | weak) + `bestScore`: how well the best existing preset covers the intent. - `draft` (only when coverage is not strong, unless `includeDraft:false`): `{ config, unvalidated:true, hint, facets, notes }`. `config` is a pasteable Renovate config assembled from a small curated facet taxonomy. This tool never validates the draft (that would require the Renovate CLI). Pass `draft.config` to `validate_config`, then `lint_config`, before adopting it — and fetch `renovate://preset/{name}` for a matched preset's full expanded body.
preview_custom_manager7 of 7 parameters describedPreview a Renovate `customManagers` entry against a local repo — fast, offline, no `renovate` invocation. Designed for iterating on a regex or JSONata customManager: shows which files match `managerFilePatterns`, what each `matchStrings` entry extracts, and what dep info the template fields produce. Limitations vs. a real Renovate run: - Supports `customType: "regex"` and `customType: "jsonata"` (the latter requires `fileFormat` to be "json", "yaml", or "toml"). - For `customType: "jsonata"`: each `matchStrings` entry is a JSONata expression that may return EITHER an array of objects OR a single object (the single object is auto-wrapped to a one-element array, mirroring Renovate's own schema). Object keys map to dep fields (`depName`, `currentValue`, `datasource`, etc.). - Template substitution stringifies non-string primitive values (e.g. numeric `currentValue: 1.2` becomes the string "1.2"); null/undefined and nested objects/arrays are dropped from the substitution bag. Same `{{groupName}}` template gap as regex — full Handlebars helpers are not implemented. - `matchStringsStrategy` other than `any` (the default) is not implemented; a warning is emitted. - `.gitignore` (and `.git/info/exclude`, plus nested `.gitignore`s) is honored like `git` does. `node_modules/` and `.git/` are always skipped as a safety net, even without a `.gitignore`. Run the `dry_run` tool afterwards for full-fidelity confirmation.
validate_config3 of 3 parameters describedValidate a Renovate configuration against the official schema using renovate-config-validator. Pass either configPath (file on disk) or configContent (inline JSON object). Returns validation output and a boolean `valid`.
lint_config2 of 2 parameters describedRun a semantic lint pass over a Renovate config. Complements validate_config: schema validation catches structural bugs, this catches Renovate-specific footguns schema validation misses — malformed '/…/' regex patterns in fields like matchPackageNames, matchDepNames, matchSourceUrls, matchCurrentVersion, plus unknown manager names in matchManagers / excludeManagers (typos that Renovate silently ignores). Each finding includes a severity ('error' | 'warn'). Offline; does not shell out. Pass either configPath (file on disk, JSON, JSONC or JSON5) or configContent (inline object).
dry_run12 of 13 parameters describedRun Renovate in dry-run mode to preview what it would do — no PRs opened, no git pushes. Returns a structured JSON report plus a top-level `ok` boolean (false when the CLI failed OR the report records a validation/error-level problem, even if the exit code was 0). RE2 native-module fallback noise and Renovate's `Unsupported node environment` notice are filtered out of `reportErrors` — the former flows into `warnings` (still actionable, still surfaced), the latter into a separate `environmentWarnings[]` since the run still produced a usable report. Effective platform = `platform` input → `RENOVATE_PLATFORM` env → `local`. The `platformSource` field on the result echoes which step won; preflight errors and the env-overrides-default advisory both reference it so callers don't have to read the source to find where a surprising `gitlab`/`github` came from. The full structured report ships inline by default. For large repos that is bigger than most MCP clients' response-content cap (≈75 KB on Claude Desktop) and the middle of the JSON is silently truncated. Pass `reportOutputPath` to redirect the structured report to a file (mode 0600), in which case `summary.report` collapses to `{ reportPath, repoCount, updateCount }` and `dry_run_diff` can pick it up via `{ reportPath: … }`. `warnings`, `problems`, `reportErrors`, and `environmentWarnings` always stay inline regardless — those are the actionable bits. **Custom base branches.** By default Renovate evaluates the repository's default branch. Pass `baseBranches` to evaluate other branches instead — this is how you dry-run a Renovate config change that lives on a feature branch before merging it. Entries are exact branch names; regex requires `/…/` wrapping (e.g. `/^renovate\/.+/`, negate with `!/…/`) — bare `^foo` is matched literally, not as regex. `$default` expands to the default branch. With `readConfigFromBaseBranch` (default true) Renovate also reads its config FROM those branches (`useBaseBranchConfig=merge`), so the branch's edited config is what gets evaluated; set it false to scan the branches' manifests using the default branch's config. Base-branch selection only applies to remote-platform runs (`platform: 'github'`/`'gitlab'`) — it is ignored (with a warning) under `platform=local`. **Auth — prefer env vars, every token bound to its host.** Set tokens on the MCP server's env via `claude_desktop_config.json` / `.mcp.json`, with the same host scoping `resolve_config` uses: `GITHUB_TOKEN` / `GITLAB_TOKEN` (and the Gitea / Forgejo / Bitbucket ones) only for their platform's public host, `RENOVATE_TOKEN` only for the home host named by `RENOVATE_PLATFORM` / `RENOVATE_ENDPOINT` (where it wins over the platform's own token, as in Renovate), `RENOVATE_MCP_HOST_TOKENS` entries for further hosts. The `platform`, `endpoint` and `presetPlatform` inputs and the repo's origin route requests but never bind an env token to another host: an endpoint passed only on the call gets a token from a `RENOVATE_MCP_HOST_TOKENS` entry or the `token` input. On a remote run (`github` / `gitlab`) the platform token — the `token` input, else the env token bound to the API host (`endpoint`, else `RENOVATE_ENDPOINT` when it belongs to that platform, else the public API) — is exported as `RENOVATE_TOKEN` to the spawned Renovate CLI; without one an actionable error is returned before spawning. Under `platform=local` no `RENOVATE_TOKEN` is exported and the `token` input is ignored with a warning. Every env token is also handed to Renovate as a host rule on its own host (`GITHUB_COM_TOKEN` excepted, Renovate reads it itself), so a `GITLAB_TOKEN` authenticates gitlab.com lookups in a local run. A malformed `RENOVATE_MCP_HOST_TOKENS` is an error before spawning. The `token` input is retained as an ad-hoc / testing fallback — when supplied inline it is persisted in the MCP tool transcript that the client may share, replay, or feed back into the LLM, so an advisory entry is appended to the result `warnings`…
dry_run_diff0 of 2 parameters describedCompute a semantic diff between two `dry_run` reports — the proposed updates that were added, removed, or changed. Stateless: pass both reports as inputs. Each side accepts either the inline report (raw `{ repositories }` or a full `dry_run` summary with a `report` key) or `{ reportPath: "<absolute path>" }` pointing at a file produced by `dry_run`'s `reportOutputPath`. Mix and match freely. Updates are keyed by `(manager, packageFile, depName)`, so a version bump on the same dep shows up under `changed` rather than as `removed + added`. Compared fields per identity: `newValue`, `newVersion`, `updateType`, `branchName`, `groupName`, `schedule`. Returns a structured summary object plus a compact human-readable text rendering.
test_package_rules29 of 29 parameters describedOffline "what-if": given a hypothetical dependency context and a config, report which `packageRules` match (in order), which matcher decided each, and what each matched rule contributes. Answers "why didn't my rule match?". Rules are evaluated with Renovate's REAL matchers in a worker thread (faithful), classified against the fields you actually supplied — a matcher that needs a field you didn't pass is reported as `unevaluatable`, never silently treated as a non-match. Matchers needing post-lookup data (matchUpdateTypes, matchCurrentVersion, matchNewValue, matchCurrentAge) or the merge-confidence API (matchConfidence) are unevaluatable offline; matchJsonata is advisory. Pass either `repoPath` (reads + expands the repo's config) or `configContent` (an inline config); `externalPresets`/`endpoint`/`platform` opt into external preset expansion so `extends`-provided rules are included (same semantics as resolve_config). Deprecated matcher keys (matchPackagePatterns, …) are warned about — run migrate_config first. Also renders the effective branchName / commitMessage / prTitle (and groupName) for the synthetic dependency under `rendered` — a preview built from the fields you supplied, which lists the post-lookup template variables it could not fill. Run dry_run for full-fidelity confirmation.
annotate_dry_run7 of 7 parameters describedGiven a `dry_run` report and a config, attribute EACH proposed update to the `packageRules` that matched it — answering "which of my rules produced these updates?". Stateless and offline: run `dry_run` first, then pass its report here (inline `report` or `reportPath`, same shapes as `dry_run_diff`) plus a config source (`repoPath` or `configContent`). Each update is matched with Renovate's REAL matchers in a worker thread against the facts present in the report; fields the report doesn't carry (e.g. datasource, depType) are reported under each update's `unevaluatable` and aggregated in `fieldGaps` rather than silently treated as non-matches. `rulesNeverMatched` flags likely-dead rules. Deprecated matcher keys are warned about — run migrate_config first. Run dry_run for full-fidelity confirmation.
explain_dependency7 of 7 parameters describedAnswer "why was/wasn't dependency X updated?" from an existing `dry_run` report — offline, no CLI. Finds every extracted occurrence of the dependency under `packageFiles` (matched case-insensitively against `depName` and `packageName`; exact by default, `partial: true` for substring) and returns per hit its `skipReason` / `skipStage`, proposed `updates`, and `warnings`, plus a one-line `verdict` (`not found in report`, `skipped: <reason>`, `up to date`, or `N update(s) available`), remedy `hints`, and `relatedProblems` (report/repo `problems` entries mentioning the dep). Pass the report inline (`report`, raw or a full `dry_run` summary) or via `reportPath` (pair with `dry_run`'s reportOutputPath). Optionally add a config source (`repoPath` or `configContent`) to attach `matchedRules` — the packageRules that matched each hit, evaluated with Renovate's real matchers in a worker thread.
explain_schedule4 of 4 parameters describedOffline: given a Renovate `schedule` (later-text like `before 4am on Monday` or cron with `*` minutes; a string or array, the same shape as the `schedule` / `automergeSchedule` options and a packageRules entry's `schedule`) and an optional `timezone`, report whether it is active at `from` (default: now) and the next `count` run windows (default 5) as ISO timestamps in both UTC and the timezone. Evaluated with Renovate's own parser and matcher in a worker thread by probing every hour over a 366-day horizon, so the windows match what Renovate's isScheduledNow decides. An invalid schedule or timezone returns `valid: false` with Renovate's own message plus the reminder that Renovate then runs at any time. Without `timezone` the schedule is evaluated in UTC — what Renovate does when the config has no `timezone` and its runner's clock is UTC. Renovate only starts work on a run that falls inside a window, so the real PR time also depends on how often it runs.
explain_paths6 of 6 parameters describedOffline: resolve the repo's config (presets included, so hidden ignorePaths like `:ignoreModulesAndTests` from config:recommended show up), list the repo's files the way Renovate does (`git ls-files`), and apply Renovate's includePaths → ignorePaths filter. Returns every pattern with the preset or `<own>` config that set it, how many files it matched and a sample; `deadPatterns` (user-owned patterns matching no file, including packageRules[].matchFileNames entries); `substringOnlyHits` (files dropped only because an ignorePaths entry is a substring of the path, e.g. `test` dropping `src/latest/package.json`, with the glob that was probably meant); per-rule matchFileNames counts against the kept files; and a summary. Pass `configContent` to try a config other than the repo's own. Same `externalPresets` / `endpoint` / `platform` opt-ins as resolve_config.
migrate_config2 of 2 parameters describedApply Renovate's built-in config migrations (deprecated key renames, template-variable rewrites, packageRules consolidation, host-rules unification, etc.) to a config and return the migrated result. Pass either configPath (file on disk, JSON or JSON5) or configContent (inline JSON object). Returns { isMigrated, migrated, diff }. Does not write — chain with write_config to persist. First call has higher latency than other tools (Renovate's migration library cold-loads in a worker thread).
write_config5 of 5 parameters describedWrite a Renovate config to disk. Runs renovate-config-validator first — refuses to write if validation fails unless force=true (which additionally requires confirmForce).
get_versionno parametersReport the renovate-mcp server version and whether it's a released build (running from node_modules) or a local/dev build (typically launched via `command: node` against a checkout). Useful when the user asks which version is wired up.
Tested in a sandbox with an empty environment: no API keys, a throwaway folder, nothing from a real account. A passing test shows the server runs and responds. It is not a security audit.