MakersMCP
# <img src="assets/logo.png" alt="MakersMCP" width="360">
Free kits for makers, one MCP. https://makersmcp.com
Open source kits for people who make things, from creators to product teams: image, video, sound, design and more. MakersMCP serves every kit to your agent through one MCP server, and they all run on your own machine, with no account or key.
## The kits
Each kit lives in its own repository and works on its own too, as a CLI and an agent skill. makersmcp comes with all of them, so no kit needs installing on its own.
| Field | Kit | Tools |
| --- | --- | --- |
| Design | [easybrandkit](https://github.com/MakersMCP/easybrandkit): a website's logo files, colors, fonts and first screen | `make_brand_kit` |
| Design | [easyfontkit](https://github.com/MakersMCP/easyfontkit): a site's fonts with their licenses and free look-alikes | `make_font_kit` |
| Image | [easyscreenshotkit](https://github.com/MakersMCP/easyscreenshotkit): clean screenshots and a short demo video of a website | `take_screenshots`, `record_demo_video`, `check_pwa_screenshots` |
| Video | [launch-film](https://github.com/MakersMCP/launch-film): a launch film with music, the launch pictures, and a check for any video | `make_launch_film`, `plan_launch_film`, `render_launch_film`, `make_launch_stills`, `check_video`, `launch_film_guide` |
| Video | [reframekit](https://github.com/MakersMCP/reframekit): one finished video in the shape, length and size each place takes, and a check of any file against a place's limits | `reframe_video`, `plan_reframe`, `check_place_limits` |
| Video | [easycaptionkit](https://github.com/MakersMCP/easycaptionkit): captions burned into a video in the brand's fonts, clear of each app's buttons, with the subtitle files | `caption_video`, `make_subtitles`, `list_caption_styles` |
| Sound | [musicfit](https://github.com/MakersMCP/musicfit): a music track cut to fit your video and laid under it | `fit_music`, `analyze_music` |
More kits are on the way.
## Set it up
You need Node 22 or newer and the Chrome, Chromium, Edge or Brave you already have. Demo videos, launch films, music, reframed videos and captions also need ffmpeg, which comes with ffprobe. Every setup runs `npx -y makersmcp@0.2.0`: keep the version in it, since `npx` can otherwise go on using an older copy it cached.
Then ask your agent for what you need, like "make a launch film for linear.app" or "get the brand kit and the fonts of stripe.com".
### Claude Code
```bash
claude mcp add makersmcp -- npx -y makersmcp@0.2.0
```
Check it with `claude mcp get makersmcp`, or `/mcp` inside Claude Code.
### Claude Desktop
Add this to `claude_desktop_config.json`, then quit Claude Desktop fully and open it again:
```json
{
"mcpServers": {
"makersmcp": {
"type": "stdio",
"command": "npx",
"args": ["-y", "makersmcp@0.2.0"]
}
}
}
```
Claude Desktop starts servers outside any project, so the files go to `~/makersmcp`, which makersmcp makes with the first job. For another folder, add `"env": { "MAKERSMCP_OUT": "<folder>" }` to the entry, like `"~/Documents/makersmcp"`: a leading `~` is your home folder.
### Cursor
Open the command palette (Cmd+Shift+P, or Ctrl+Shift+P on Windows and Linux), run "Open MCP settings" and add:
```json
{
"mcpServers": {
"makersmcp": {
"command": "npx",
"args": ["-y", "makersmcp@0.2.0"]
}
}
}
```
### VS Code
```bash
code --add-mcp '{"name":"makersmcp","command":"npx","args":["-y","makersmcp@0.2.0"]}'
```
### Codex
```bash
codex mcp add makersmcp -- npx -y makersmcp@0.2.0
```
### Windsurf
Open Settings, then MCP, and add the same entry as for Cursor.
### OpenClaw
Add it under `mcp.servers` in your OpenClaw config:
```json
{
"mcp": {
"servers": {
"makersmcp": {
"command": "npx",
"args": ["-y", "makersmcp@0.2.0"]
}
}
}
}
```
Check it with `openclaw mcp doctor makersmcp --probe`.
### Hermes
Add it under `mcp_servers` in `~/.hermes/config.yaml`, then run `/reload-mcp`:
```yaml
mcp_servers:
makersmcp:
command: "npx"
args: ["-y", "makersmcp@0.2.0"]
timeout: 60
```
### Other clients
Any MCP client that runs stdio servers can start it with `npx -y makersmcp@0.2.0`.
### Run it from source
```bash
git clone https://github.com/MakersMCP/makersmcp.git
cd makersmcp
npm install
npm run build
```
In any setup above, use `node` as the command and the full path of `dist/index.js` as its argument. `node dist/index.js --check` lists the kits it found, the Chrome and the ffmpeg found for them (and ffprobe while launch-film is on) and the folder it saves to.
## Pick your kits
Every kit is on unless you say otherwise. To give your agent fewer tools, name the kits you use:
```bash
npx -y makersmcp@0.2.0 # every kit
npx -y makersmcp@0.2.0 --kits all # every kit, the same
npx -y makersmcp@0.2.0 --kits easybrandkit,launch-film # only these two
```
In a client's settings, the same goes at the end of `args`, like `["-y", "makersmcp@0.2.0", "--kits", "easybrandkit,launch-film"]`.
## Where the files go
Every tool saves its files in a folder and returns the folder, the files it saved there and the kit's own notes, like BRAND.md. The folders go where makersmcp starts, which is your project for a coding agent, or `~/makersmcp` when it can't write there; a folder that is not there yet is made with the first job. A tool given a video, like `reframe_video` or `caption_video`, saves in a folder next to that video. Every kit puts a run's files in place only once the run has ended well, so a run that fails or is canceled leaves its folder as it was. Choose another place with `--out <dir>` or `MAKERSMCP_OUT`, or give a tool its own `out_dir`. A call with an argument the tool does not take, like `output_dir`, is refused with the one it most likely meant, and starts nothing.
launch-film keeps the brand kit a film uses in a `brand/` folder next to film.json. When it plans from a brand kit you give it, it deletes that folder and makes it again, and from an App Store page it may; from any other site, easybrandkit makes the kit again in it, replacing only a kit's own files. Its tools tell the client they may replace files, and they do not start when makersmcp finds they would lose anything in that `brand/` but a kit's own files: a file you added, a file named like a kit's own in other letters or with a character that does not show, a link the kit would delete files through, or a kit you give that is that same `brand/` folder under another name, holds it, or has its brand.json as a link into it. To use a `brand/` folder where it is, give it as `brand` written the way `out_dir` is, with `/brand` added. makersmcp looks only before the kit starts, and a folder mounted from the same disk, inside `brand/` or as the `out_dir`, can still hide from it where it really is, so keep files you care about outside `brand/`.
A long job, like rendering a film, keeps going after the tool returns. The tool then gives back a `job_id`, and your agent calls `wait_for_job` with it until the job ends. `list_jobs` and `cancel_job` do what they say, and `check_setup` tells what is missing when a kit fails to start. When the client closes makersmcp, or makersmcp ends some other way, its jobs stop too, with the browsers and ffmpeg they started.
## When something fails
- The tools don't appear: check that `node --version` says 22 or newer, then restart the client. `npx -y makersmcp@0.2.0 --check` lists what makersmcp found.
- A kit's tools are missing: `--check` says why. Every kit comes with makersmcp, so look at `--kits` and `--kit-path`, and from source run `npm install` again after a pull.
- A kit can't find Chrome or ffmpeg: set `CHROME_PATH` and `FFMPEG_PATH` in the server's `env`. makersmcp gives them to every kit, to launch-film as `LAUNCH_FILM_CHROME` and `LAUNCH_FILM_FFMPEG` too, with `LAUNCH_FILM_FFPROBE` the ffprobe beside that ffmpeg. Without them, it gives each kit the Chrome and the ffmpeg `--check` shows. A setting names a program by its path, or by a command name on PATH like `ffmpeg`. `--check` also names a setting that leads to no program, and until it is fixed makersmcp starts no tool that reads a program from it.
- A long job meets the client's time limit: no call waits longer than `wait_seconds`, 45 by default, counted from the start of the call. A job still running then comes back with a `job_id` and `next_action: wait_for_job`, and the agent should call that, never the first tool again, which would start a second job. A call the client gave up on is still covered: the same call again within 10 minutes continues its job, and says so, instead of starting another. Where a client lets you set a tool timeout, keep it above 45 seconds.
## Settings
| Option | Environment | What it does |
| --- | --- | --- |
| `--kits <list>` | `MAKERSMCP_KITS` | turns on only these kits, like `easybrandkit,launch-film`; leave it out or give `all` for every kit |
| `--out <dir>` | `MAKERSMCP_OUT` | where the folders go, made with the first job; `~` is your home folder |
| `--kit-path <kit>=<dir>` | `MAKERSMCP_KIT_PATHS` | runs a kit's checkout instead of the package that comes with makersmcp; `~` is your home folder |
| `--check` | | prints the kits, the Chrome and the ffmpeg found for them (and ffprobe while launch-film is on) and the folder, and exits |
## Use it in your own server
```js
import { serveStdio } from 'makersmcp';
await serveStdio({ kits: ['easybrandkit', 'launch-film'], outDir: '/srv/makersmcp' });
```
`serveStdio` serves on stdin and stdout and ends the process when the client goes away. `createMcpServer` takes the same options, `kits`, `outDir`, `kitPaths`, `definitions`, `backend` and `maxToolInputElements`, and works over any MCP transport; close the server when the client is gone, since the stdio transport alone never notices. `maxToolInputElements` is the most array items and object members one tool call may carry, 10,000 unless you give another, and `Infinity` turns that check off: a call with more gets one short error before its arguments are checked, and starts nothing. A kit tool call identical to one whose answer did not reach the client, cancelled or cut off with its connection, continues that call's job for 10 minutes, and so does one made at least 10 seconds after an identical call that still waits; `repeatTiming` changes both times. This holds for the calls of one backend `identity` in one process: `LocalBackend` has one of its own, and a hosted backend gives the user its jobs belong to. The backend decides where the jobs run. The default, `LocalBackend`, runs them on this machine and stops them when the server closes or the process ends. A service that runs kits for others can give `LocalBackend` an `env` of its own, so its secrets never reach a kit, and `confine: true`, so no tool call can name a file or folder outside `baseDir`, and no job returns a doc or lists a file a kit left outside it or behind a link. To run its kits as another user, it gives a `launcher`: a command that execs makersmcp's `dist/supervise.js` in place of itself with the kit's script and arguments, like `["sudo", "-n", "-u", "<kit user>", "--", "<wrapper>", "run"]`. No signal reaches another user's processes, so a cancel then closes the supervisor's stdin, and the supervisor stops the kit; a job's `pid` is its process group, the one to keep while it runs when the service sweeps up what kits left behind. A service can also pass its own `KitBackend` ([src/backend.ts](src/backend.ts)) to run them on its machines; the tools then take a file an earlier job saved, as `job:<job_id>/<path>`, or a link where a parameter takes one, instead of paths, and return links to the files. A call that leaves out a parameter with a hosted default reaches such a backend with that value, and a parameter the tools there leave out has it in every call, like `jobs` 1, so a launch film renders one clip at a time there; a service that starts a job another way gets the kit's own default. Where its job view has a value of another type than `JobView` gives, like a file whose path is not text, the result leaves that value out and shows the rest. `loadKitDefinitions`, `validateKitDefinition`, `buildCommand` and `describeSetup` are exported too.
## Add a kit
makersmcp has no code for any kit. Each kit is a JSON file in [kits/](kits) that names its npm package, its tools, and how each tool's parameters become the kit's arguments. A new kit is a new file there and its package in the `dependencies` of `package.json`, which is how it comes with makersmcp; removing a kit is the reverse, and `npm test` fails while the two do not match. [docs/kits.md](docs/kits.md) describes the file.
## Develop
```bash
npm install
npm test
```
To try changes to a kit that are not on npm yet, start makersmcp with `--kit-path <kit>=<folder>`, like `--kit-path musicfit=../musicfit`, and it runs that checkout instead of the package. `npm test` tries the bounds of every number in kits/ with each kit's package; `MAKERSMCP_KIT_PATHS=musicfit=../musicfit npm test` tries the checkout's instead.
[MIT](LICENSE)
TDQS
Scored across 24 tools
Despite 24 tools spanning six kits, the descriptions do heavy lifting: each overlapping pair (caption_video vs make_subtitles, check_video vs check_place_limits, reframe_video vs plan_reframe, make_brand_kit vs make_font_kit, take_screenshots vs make_launch_stills) explicitly names its sibling and says when to use the other instead. The plan/render/make triads for launch films are cleanly separated by their side-effect contract (writes film.json vs renders film.mp4). Minor residual confusion remains between the four checking tools and between the two screenshot tools, which an agent must re-read to select.
Nearly everything is snake_case verb_noun (take_screenshots, record_demo_video, plan_launch_film, fit_music, cancel_job, list_jobs), which makes scanning predictable. The deviations are noun-first or bare-noun names: launch_film_guide, makersmcp_playbook, and arguably check_setup within the job tool group. These are readable and few, so the pattern holds overall.
24 tools is on the heavy side of the ideal band, but the surface is genuinely four-to-five sub-products (brand, fonts, screenshots/demo, launch film, captions, music, reframe) plus job orchestration and diagnostics, and each tool maps to a distinct step rather than duplicating another. The plan/check/inspect variants are optional but earn their place by preventing costly re-renders. It would still benefit from consolidation of the check_* family.
The lifecycle is well covered: asset acquisition (brand, fonts, screenshots), production (demo, launch film, stills), post (captions, subtitles, music fitting, reframe), verification (three check tools), and job control (start/wait/list/cancel) plus setup diagnostics. The main gap is upstream of captions: no tool produces word-level timings from a video or audio, so a user without a speech-to-text file is a dead end, and there is no generic trim/concat or audio voiceover utility.