Skip to main content
The Mzizi MCP server gives agents the registry, the brand tokens, the architecture model, the doctrine, the agent skills and these docs over the Model Context Protocol. It is the 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

Streamable HTTP. 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 stdio build takes no environment and holds no credential. The registry data and skills ship inside the package.

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:
The first hit is the 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:
The answer is the component’s full document, Rust first. The same two calls work for any hit. Use 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 except fundi 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, named mzizi_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 as mzizi-brand;
  • install.cargo: cargo add <crate>, the crates.io release;
  • install.pinned: the same cargo add with --git and --rev at the server’s registry pin, which builds exactly the source shown;
  • module: the crate’s Rust path, such as mzizi_brand;
  • contract: the component’s contract … end block, or null when its source declares none;
  • files: the .rs source, 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.
Breaking for readers of 0.10.x: the React body moved from component to react, and renamedFrom moved to the top level.
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 at https://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.
The 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.
Both act for a real, signed-in console user. The server never hands a machine credential to a client or to the CLI.

Use cases

Building against the registry

  1. mzizi_search for the name, or list_components through mzizi_execute, filtered to the node you are building at.
  2. mzizi_execute with get_component for the full document of anything that looks right. Where a Rust implementation exists, it leads: depend on the crate in rust.install (see Mzizi Roots).
  3. Install it (see consuming the registry).

Reviewing a change

  1. get_tokens to check a component uses published tokens, not raw values.
  2. get_architecture to check it sits where its imports say it does.
  3. check_accessibility for 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.