mzizi-mcp Cloudflare
Worker, published as @nyuchi/mzizi-mcp
(0.24.0 as of 17 November 2026). In the
MCP Registry it is
io.github.mzizi-dev/mzizi-mcp, listing both the hosted endpoint and the npm package.
From 17 November 2026 the server exposes three tools. Every operation it used to offer as
its own tool is now run through one of them. The earlier tool names still work until 1.0.0;
see the earlier tool names.
Connecting
mzizi.dev/mcp answers 308 to this endpoint, so old clients keep
working, but point new ones here directly.
Each client writes this in its own format. Connect a client has the
current one for each client, and says how the skills reach each.
To run it locally over stdio, with no network for anything but the docs tools:
The three tools
The pattern is always the same: search, then execute.
mzizi_search tells you what
exists and what each operation takes. mzizi_execute runs it.
Search, then execute
This is a real exchange, as the server answered on 17 November 2026. First, search for a word:button component. Its rustCrate is mzizi-ui, so it has a Mzizi
Roots (Rust) implementation, and that is the lead. The same response lists the operations
the caller may run, including get_component, with the arguments it takes.
Then run the operation you chose:
mzizi_search to find the name and mzizi_execute to read it.
The operations
These need no account:
The sign-in operation is
fundi. It needs a signed-in console user, and a refused call says
how to sign in.
mzizi_search returns each operation’s own arguments, so the table above does not have to
be kept in step with the server. Ask the server, not a page.
Who can use it
The MCP server is free, with no gate, as the owner decided on 29 September 2026. Every operation exceptfundi is served without sign-in, and so is mzizi_feedback with
target: "docs".
The sign-in calls stay gated because they tie into the console at
app.mzizi.dev. Filing an
issue and running fundi both act for a user, so the server needs to know who that is. The
server advertises its OAuth metadata at
/.well-known/oauth-protected-resource,
so MCP clients can run the sign-in flow themselves. Called without sign-in, a gated call
answers with how to sign in rather than failing silently. An anonymous issue report is not lost: the answer carries a pre-filled GitHub issue link you can submit, for mzizi-dev/mzizi-registry. Over HTTP the server also answers with an
OAuth challenge, so a client can offer sign-in. A client that cannot run the flow can connect
to https://mcp.mzizi.dev/mcp/signin instead, which asks you to sign in and then serves every
tool.
Anonymous requests are rate-limited to 120 per 60 seconds per IP address, according to the
server’s catalogue.json. Signed-in requests are not.
The earlier tool names
The server first shipped with one tool per operation, namedmzizi_get_component,
mzizi_get_tokens and so on. Those names still work, both as direct tool calls and as
mzizi_execute operation names, until 1.0.0, when they are removed. A direct call to an
old name returns _meta.deprecated, which names the new call. Clients written against them
do not need to change yet. New clients should use the three tools.
Pages on this site that show a call use the new form.
Components, Rust first
The component operations lead with Mzizi Roots, the Rust implementation, wherever one exists. The pure Astro build comes next, where there is one. The React (TSX) components are the React build: they keep working, but they are deprioritised and come last.get_component takes name (a former nyuchi-* name resolves to its mzizi-* successor)
and an optional include of "docs", "versions" or both. It answers with these fields, in
this order:
rust is the registry’s GET /v1/rs/{name} answer, with the install before the source:
crate:{ name, registry, git }, the crate the component ships in, such asmzizi-brand;install.cargo:cargo add <crate>, the crates.io release;install.pinned: the samecargo addwith--gitand--revat the server’s registry pin, which builds exactly the source shown;module: the crate’s Rust path, such asmzizi_brand;contract: the component’scontract … endblock, ornullwhen its source declares none;files: the.rssource, inline.
astro is build: "astro", install (npx @nyuchi/mzizi-cli add <name> --target astro),
api (https://api.mzizi.dev/v1/astro/<name>), installsTo (src/components/mzizi/), the
files it installs, and their dependencies and registryDependencies. See
the CLI for the Astro target.
react.install is npx shadcn@latest add https://api.mzizi.dev/v1/ui/<name>. If the registry
refuses the React build but Rust exists, react is { build, error } and the Rust still leads.
list_components rows carry rustCrate when the component has Rust, the response carries
withRust (how many of total have it), and rust: true or rust: false filters on it. The
same goes for Astro: rows carry astroFile, the response carries withAstro, and
astro: true or astro: false filters on it. search component hits carry rustCrate and
astroFile the same way, and at an equal score a component with Rust ranks first; a better
word match still wins.
Where its data comes from
Nothing is read from a database, and no registry data is fetched at request time.catalogue.json names the pinned registry commit in source.registry, and the describe
operation reports it. Read the live pin there rather than from this page, and compare it with
the pin api.mzizi.dev reports in its X-Mzizi-Source header. The
two are meant to be the same commit, but they move separately, so they can differ for a
while after one of them moves. Moving to newer registry content is a change to that pin, made
in a pull request that CI checks.
The pin, ref in mzizi-mcp/registry.pin.json, has the same bot as
the API gateway’s. It compares the pin with registry
main and keeps one pull request that moves it. That pull request merges itself only when
every check on it is green, and otherwise waits for review. A bump by hand still works.
The server holds no database credential. Former nyuchi-* component names resolve to their
mzizi-* names through the registry’s rename map, bundled with the rest.
The skills
get_skills serves the skills of @nyuchi/mzizi-skills, bundled from the
skills’ source when the server is built. It takes category: dev, design, language or
build returns every skill in that category in full. category: "dev" is what every Mzizi
repository’s AGENTS.md asks an agent to load before it starts. Asking for a name outside
the category you named is an error. The skills renamed or removed in 0.8.0 of the bundle
have no aliases; see renamed and removed skills.
The docs operations
These docs run their own MCP server, which Mintlify hosts athttps://docs.mzizi.dev/mcp.
It is public and needs no sign-in. The Mzizi MCP server runs its tools as docs_*
operations and forwards each call unchanged:
- it caches the upstream tool list for five minutes;
- if a refresh fails it reuses the last good list, and with nothing cached it falls back to a built-in snapshot of the upstream definitions;
- a failed call comes back as an error naming the docs server and the reason.
docs_* names mirror whatever docs.mzizi.dev/mcp lists, so they can change when these
docs change. You can also connect to https://docs.mzizi.dev/mcp directly.
The sign-in operations
mzizi_feedback files an issue on your issue desk. The desk reproduces the problem,
drafts an issue with what the reproduction returned, and logs it to Fundi. Fundi files the
GitHub issue and tracks it. action: "get" shows where your report got to, and "list"
shows your reports. Filing needs sign-in. Without it, you get the pre-filled GitHub issue
described above. With target: "docs", it reports a problem with a page on docs.mzizi.dev, and
needs no account.
fundi, run through mzizi_execute, delegates long runs, such as a security, chaos or
accessibility run, to Fundi, the self-healing agent behind the console, which runs under
Nyuchi. It uses the Agent2Agent (A2A) protocol. A run is a task with a lifecycle, not a
blocking call: you submit it and get a task id back at once, then poll its status or cancel
it.
The A2A bridge is built through its second stage: the agent card, task submission, status
and cancellation. The runs behind it, streaming updates and push notifications are still
design. A submitted task can come back parked as accepted but not executed.
Use cases
Building against the registry
mzizi_searchfor the name, orlist_componentsthroughmzizi_execute, filtered to the node you are building at.mzizi_executewithget_componentfor the full document of anything that looks right. Where a Rust implementation exists, it leads: depend on the crate inrust.install(see Mzizi Roots).- Install it (see consuming the registry).
Reviewing a change
get_tokensto check a component uses published tokens, not raw values.get_architectureto check it sits where its imports say it does.check_accessibilityfor contrast on any new colour pairing.
Answering a question about Mzizi
mzizi_search finds the docs match. Then mzizi_execute with docs_query_docs_filesystem_mzizi
reads the page it found.