Ratatosk
Summary: Ratatosk is an MCP server that gives AI agents typed, entity-level CNCF release intelligence (security fixes, breaking changes, deprecations, changed defaults) so they can answer upgrade and config-impact questions.
Check a running stack (
check_stack) — pass component versions and get the changes on your upgrade path, split intoaction_required(applies to everyone) vscheck_config(only ifapplies_ifmatches your setup); branch/line-aware, with optionaltarget_version,severity_min, anddetail:"full".Sync the change feed (
list_changes) — page through changes oldest-first via asincecursor to keep a local copy up to date, filtered by project, family, or bucket.Reverse-lookup by identifier (
changes_by_entity) — find every change touching an exact CVE id, CRD, feature gate, flag, metric, config field, or dependency.Trace a matter across releases (
get_matter) — see every release where onematter_keyappeared, so you know which versions fix it for your branch.Inspect one release (
get_release) — get a release's full changes, summary, source links, cited advisories with current severity, verbatim quotes, and optionally the raw note body.Scan recent releases (
list_releases) — newest-first one-line summaries with counts by bucket/family and max severity for "what changed in X lately".Discover tracked projects (
list_projects) — resolve canonical slugs, tiers, categories, image aliases, and cluster-core components before calling other tools.Privacy-aware —
check_stackcompares versions inside the server process and sends only project slugs upstream; no account or API key required (hosted or self-hosted).
ratatosk-mcp
Ratatosk reads CNCF release notes every hour. Your agents get the changes.
In Norse myth, Ratatoskr is the squirrel that carries messages up and down the world tree. This one carries release intelligence. ratatosk.io watches 76 CNCF projects and turns every release note into typed, entity-level changes: security fixes, breaking changes, removals, deprecations, changed defaults — each one classified by how you should act on it now. Routine lines are recorded too, but kept out of the way.
This repository is the MCP server that hands those changes to your agent as tools. MCP (Model Context Protocol) is the open standard AI agents use to call external tools; any MCP-capable client — Claude Code, Claude Desktop, kagent, your own SDK agent — can connect. No account, no API key.
Two ways to connect
Hosted — nothing to install. Register https://ratatosk.io/mcp as a
remote MCP server in any client that supports remote connectors. The hosted
endpoint allows each caller 60 tool calls a minute, counted per caller rather
than pooled — for polling or CI workloads, self-host. With the Claude Code
CLI:
claude mcp add --transport http ratatosk https://ratatosk.io/mcpSelf-hosted — the same server, running as your own process. Run it with Docker, the Helm chart, or a source build. With Claude Code and Docker installed:
claude mcp add ratatosk -- docker run -i --rm ghcr.io/basphere/ratatosk-mcp:0.10.00.10.0 is the current release; use latest to follow new ones.
Either way, verify the connection:
claude mcp list
# ratatosk: … - ✔ ConnectedThen ask your agent a question the tools can answer:
You: "We run envoy v1.36.8 and istio 1.30.1. Anything we must do before upgrading?"
Your agent calls
check_stackand answers from the record: the CVEs fixed after your version, the APIs removed on your upgrade path, the defaults that changed — separated into what applies to everyone and what applies only if your configuration matches. Each change carries a verbatim quote from the release notes as evidence.
One entry from a real check_stack answer, as the agent receives it
(istio, measured 2026-08-20):
{
"severity": "high",
"family": "security",
"bucket": "action",
"applies_if": "uses JWKS Resolver",
"quote": "- CVE-2026-31837 / GHSA-v75c-crr9-733c : (CVSS score 8.7, High): JWKS Resolver Failure May Allow Authentication Bypass Using Known Default Keys.",
"same_matter_also_addressed_in": ["1.28.5", "1.29.1"]
}applies_if is a condition the agent evaluates, not prose to read: a stack
that runs no JWKS resolver skips this entry without asking anyone. The answer
also carries its own privacy line, verbatim: "versions were compared locally;
only project slugs were sent to the server."
Other clients (Claude Desktop, kagent, in-cluster agents) and the full setup reference: see the install guide.
Related MCP server: driftwatch-mcp
Tools
Two things the tools speak in. A change is one thing a release did, taken from an official release note and tied to the exact identifiers it touches (a CVE id, a flag, a CRD, a config field), with a verbatim quote as evidence. Every change carries three axes:
family —
security,breaking, ordeprecated: what kind of thing it is.bucket —
action(applies to everyone),check(only ifapplies_ifmatches your setup),plan(announced for later),other(the full record).applies_if — a boolean expression you can evaluate against your own manifests, not prose to read.
A matter is the issue underneath, identified by matter_key and stable
across releases and branches: the same security roll-up landing on five
branches shares one key. Severity lives on the cited advisories and is read
from the ledger's current value, not frozen at analysis time.
Tool | What it does |
| Takes the component versions you run and returns the changes on your upgrade path, split by bucket: |
| The incremental change feed, oldest-analyzed first. Filter by project, family, or bucket; page with the |
| Reverse lookup: every change touching one exact identifier — such as a CVE id, CRD, feature gate, flag, config field, or dependency |
| Every release in which one matter appeared. The same roll-up lands on several branches carrying different advisories — told only the newest, you would assume you were covered |
| One release in full: its changes, a summary, and the link to the original note. A release with zero changes means it was read and found routine |
| The newest releases of one project as one-line summaries (dates, counts by bucket and family, highest advisory severity), newest first — the tool for "what changed in X lately" |
| The roster of tracked projects and their canonical slugs (the short project id every other tool takes) — look names up here instead of guessing |
Full per-tool parameters, example calls, and measured responses live in the tools reference.
How your component versions are handled
Self-hosted: check_stack sends only project slugs to the server and
compares versions locally, inside this process — the versions you pass it
never reach ratatosk.io. The server publishes changes; your agent decides what
applies. The version normalizer is bundled (internal/version), so range
comparison happens client-side too. This holds for upgrade questions as well:
the upstream API has a convenience endpoint (/v1/upgrade/{project}) that
receives caller-supplied versions — check_stack does not call it; the
comparison is in the source you can read.
One limit on that guarantee: it covers check_stack. Tools that take a
version as an argument — get_release(project, version) — put that version
in the upstream request path, because fetching a specific release means
naming it. That named path is not kept on my side, though: before a log line
is written, query strings are stripped and /v1/releases/… and
/v1/upgrade/… paths are reduced to their prefix, so neither the slug nor
the version lands in a log.
Hosted: your check_stack arguments (the versions you run) pass through
the server's memory to produce the same answer, and are not written down.
Here is what each layer on the way keeps:
The hosted MCP process itself logs only its startup line — a normal request adds nothing.
The upstream API's request log writes one line only when the caller sends a
traceparent, and that line carries a normalized endpoint label and the trace id — never a path, query, or body.The front-door access log strips query strings, reduces
/v1/releases/…and/v1/upgrade/…paths to their prefix, masks caller IPs, and has no field for request bodies.
The hosted endpoint runs with its audit stream off, and I keep it off — not
recording request content is the operating stance for that endpoint. One
boundary I do not control: connection metadata on the CDN leg
follows the CDN provider's own policy. If your requirements rule out that transit,
self-host: then only project slugs leave your infrastructure on a
check_stack call.
Self-hosting adds the opposite capability: an opt-in audit stream
(MCP_AUDIT=metadata or full) that records who called which tool, emitted
inside your own infrastructure into your own collectors. The hosted endpoint
has none by design. Details in the install guide.
Documentation
Install & usage — hosted endpoint · local stdio · in-cluster (Helm) · kagent (한국어 · 日本語)
Helm chart — values, kagent toggle (한국어 · 日本語)
kagent example — manifests + ratatosk-agent (한국어 · 日本語)
Upstream API
This server is a thin client over the public REST API. If you would rather
call it directly, GET /v1 on ratatosk.io describes itself. No API key; rate
limited at 1200 requests per minute per IP.
Data & terms
The data is served free of charge by ratatosk.io — a term that may change,
with advance notice — under its terms of service.
Analyses are AI-generated reference information with no warranty — check the
original release notes before acting, especially when an agent acts on your
behalf. Original notes belong to their respective projects; responses that
carry a full note include an attribution notice (raw_notes_notice).
License
The code in this repository is licensed under Apache-2.0.
Available Tools
7 toolschanges_by_entityARead-only
Reverse index: every change touching one exact identifier — a CVE id, CRD, feature gate, flag, metric, config field, or dependency. Case-insensitive. Call this when you have a specific identifier (e.g. from a manifest or advisory) and want to know what changed around it.
Inputs: name (required), kind.
check_stackARead-only
Check the user's running component versions against known changes. Versions are compared INSIDE THIS SERVER PROCESS — only project slugs are sent upstream, and this tool never calls the server-side /v1/upgrade endpoint. Run the server yourself and running versions never leave your infrastructure; on the hosted endpoint they transit server memory only and are not logged. Returns, per component, the changes from releases NEWER than the running version (the upgrade path). Default is a briefing: summary (new_changes, distinct_matters, by_severity, by_family, by_bucket), then the items split by what the caller must do — action_required applies to everyone, check_config applies only if its applies_if holds against the running configuration (resolve it before recommending; an unmet condition is not a reason to upgrade, it is a precondition for later — the entry's version is the minimum to be on before enabling that feature). The split comes from the server's bucket field, the SAME rule the website and the weekly email use. Repeat appearances of one matter_key (the same issue fixed on several release branches) collapse into one entry, and same_matter_also_addressed_in names every other release on record that carried it. Branch-aware: a matter already fixed at or below the running version ON THE RUNNING BRANCH is excluded (the install has it), counted in note — so a backport visible on a newer branch is not reported as outstanding work. Line-aware: a repository can publish separate products or channels (containerd api/, Flatcar lts vs stable, openfeature flagd vs core) and there is NO version order between lines, so only the line your version belongs to is compared — pass the tag as published, prefix included ("flagd/v0.16.1", "lts-4081.3.9"), or the wrong line is compared. Pass version_source per component (where you read the version — e.g. a daemonset image tag, or that the user stated it): it is echoed back as an audit trail. This server cannot see your environment, so it cannot verify a version or its source; a running version older than every release on record is flagged in note, which is the only cross-check available here. Use detail:"full" for every change verbatim in relevant_changes (capped at 50 per component with relevant_changes_omitted — narrow with severity_min or target_version), target_version to limit to one upgrade hop, severity_min to filter. Components with zero changes carry tracked:true|false — tracked:false means the project is NOT covered by ratatosk, so the absence of changes is no-coverage, not safety. Drill down with get_release or changes_by_entity.
Inputs: components (required), detail, severity_min.
get_matterARead-only
Every release in which one matter appeared, oldest first. Take matter_key verbatim from a change (case-sensitive, contains '/' and ':'). Use it to answer 'which version fixes this for MY branch' and 'have I already handled this'. Why every occurrence and not just the newest: the same containerd security roll-up landed on five branches carrying 2, 4 and 10 advisories respectively — told only the newest, someone on the 2-advisory branch would assume they were fully covered. Set include_all for the routine record too (mostly bot dependency bumps).
Inputs: matter_key (required), include_all.
get_releaseARead-only
One reviewed release: envelope (summary, source URL, release URL) plus all its changes. changes=[] means the release was read and nothing operator-facing was recorded — auditable silence, not a gap. Each change carries family (security|breaking|deprecated), actionability, bucket (act now / check first / plan ahead), a machine-evaluable applies_if, cited advisories with CURRENT severity, and the verbatim quote it came from. by_bucket/by_family/max_severity summarize the same set; notes_total counts routine entries not shown individually. Omit version for the latest reviewed release of the project. version is accepted with or without the leading 'v' (projects disagree on the spelling); a wrong tag returns an error listing the project's recent reviewed tags — retry with one of those. Set include_raw for the original release note body (raw_notes).
Inputs: project (required), version, include_raw.
list_changesARead-only
Incremental SYNC feed of release changes for CNCF/cloud-native projects. Ordered by seq ascending — OLDEST analyzed first, so a single page is NOT the newest data; page through with since= until next_since comes back null. Built for keeping a local copy up to date. For 'what is the latest release of X' or 'recent releases of X', use list_releases or get_release (omit version for the newest) instead. Filter by project, by family (security|breaking|deprecated — what kind of thing it is) and by bucket (action|check|plan — how to act now). The routine record (bot dependency bumps and the like) is excluded by default. Two fields matter most: applies_if tells you whether an entry is yours to act on — when its targets are present, look them up in the running configuration instead of parsing the sentence; matter_key is the identity of the underlying matter across releases, which get_matter expands.
Inputs: limit, since, bucket, family, +1 more.
list_projectsARead-only
Every project ratatosk tracks: slug (the canonical id all other tools take), name, tier (graduated|incubating), category, analyzed_releases; image_aliases where a project runs under other names in clusters (an image or workload matching an alias belongs to that project at the version its tag says), and cluster_core:true on the cluster substrate (control plane, datastore, DNS, runtime, CNI/dataplane) — every cluster_core project present in a cluster belongs in its check_stack call. Some cluster_core entries carry a visibility hint (how the component is observed and where it can legitimately be unreadable — e.g. etcd may live outside the k8s API): an unreadable one is reported as unchecked, never guessed. Small response, no arguments — call this FIRST when you are unsure of a slug instead of guessing (a wrong slug shows up as tracked:false in check_stack).
list_releasesARead-only
The newest N reviewed releases of one project, as light summaries (version, released/reviewed dates, changes_total, counts by bucket and by family, max advisory severity, notes_total). THE tool for 'recent releases of X' / 'what changed in X lately' — newest first, unlike the list_changes sync feed which walks oldest-first by seq. changes_total=0 means the release was read and is routine (auditable silence). Drill into a row with get_release(project, version) for the full changes.
Inputs: project (required), limit.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Each tool has a distinct role: project discovery, release summaries, release detail, change feed, matter expansion, entity reverse lookup, and running-stack comparison. The descriptions explicitly call out when not to use a particular tool, which removes most ambiguity.
Six of seven tools follow a clear verb_noun pattern: get_release, get_matter, list_releases, list_changes, list_projects, check_stack. The exception is changes_by_entity, which is a noun phrase rather than a verb-led name, but all names are still lowercase snake_case and otherwise predictable.
Seven tools is a well-scoped size for this domain. Each tool covers a distinct part of the release-change and upgrade-analysis workflow, and none feels redundant or superfluous.
The toolset covers the full workflow: discovering tracked projects, listing releases, reading release details, syncing change feeds, expanding matters across releases, doing entity-based reverse lookup, and checking a running stack against known changes. Drill-down paths are explicit and there are no obvious dead ends.
Maintenance
Related MCP Connectors
Check exact npm/PyPI upgrades for evidence-backed breaking changes; query APIs and components.
Release notes and changelogs from across the web, indexed for agents. Also via CLI and REST API.
Latest versions, LTS windows, and EOL dates for 300+ products. Fresh ground truth for stale models.
What breaks between versions, vulnerabilities, compatible versions, EOL dates: npm, PyPI, Rust, PHP.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables querying the CNCF landscape to search for projects, get detailed information, GitHub metrics, maturity status, and case studies for technology decision support.4Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables AI coding agents to identify exactly what broke between two dependency versions, with citations for every claim, and to verify package existence to catch typosquatting, all without requiring an API key.MIT
- AlicenseAqualityBmaintenanceEnables checking project files like Dockerfile, .nvmrc, and CI workflows to determine whether pinned runtime, database, and OS versions are still supported, providing end-of-life dates, latest patches, and upgrade targets for 470+ products.31MIT
- AlicenseAqualityBmaintenanceVerified, dated facts for AI coding agents: what breaks between npm package versions (diffed from TypeScript types), per-version vulnerabilities, the newest version compatible with a given Node/Python/Rust/PHP, end-of-life dates of ~480 runtimes and frameworks, and AI model prices. Covers npm, PyPI, crates.io and Packagist.121AGPL 3.0