Skip to main content
Glama

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: a website's logo files, colors, fonts and first screen

make_brand_kit

Design

easyfontkit: a site's fonts with their licenses and free look-alikes

make_font_kit

Image

easyscreenshotkit: clean screenshots and a short demo video of a website

take_screenshots, record_demo_video, check_pwa_screenshots

Video

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: 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: 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: a music track cut to fit your video and laid under it

fit_music, analyze_music

More kits are on the way.

Related MCP server: postward-creative-mcp

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

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:

{
  "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:

{
  "mcpServers": {
    "makersmcp": {
      "command": "npx",
      "args": ["-y", "makersmcp@0.2.0"]
    }
  }
}

VS Code

code --add-mcp '{"name":"makersmcp","command":"npx","args":["-y","makersmcp@0.2.0"]}'

Codex

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:

{
  "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:

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

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:

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

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) 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/ 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 describes the file.

Develop

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

Available Tools

24 tools
analyze_musicRead a music trackA
Destructive
Inspect

Use it when the user wants a track's tempo, beats, bars, drop or ending. Reads a music track's tempo, beats, bars, drop and ending, and writes FIT.md (the tempo, the drop and the other drop candidates, where sections start, how it ends and any warning), cues.json (beats and bars in seconds, and as frames at 30 a second) and seams.png (the track with its bars). It changes no track, and saves in a folder of its own, apart from fit_music's for the same track. Its tempo tells which launch film look the track suits. Use it before fit_music to pick hit and drop. To fit the track, use fit_music instead. The music playbook (makersmcp_playbook) has the whole job. (musicfit 0.2.2, on this machine.)

Inputs: track (required), bpm, meter, out_dir, +1 more. Returns: kit, docs, next, tool, +11 more

cancel_jobCancel a jobA
DestructiveIdempotent
Inspect

Stops a running job and the browser or ffmpeg it started. Files it already saved stay where they are.

Inputs: job_id (required). Returns: kit, docs, next, tool, +11 more

caption_videoCaptions burned into a videoA
Destructive
Inspect

Use it when the user wants captions or subtitles burned into a video, to read with the sound off, karaoke style or in the brand's fonts, clear of an app's buttons. Burns captions into a video from words with times the user already has: a speech-to-text JSON with word or line times, from OpenAI, whisper.cpp, Deepgram and others, an SRT or WebVTT file, or a demo's steps file, whose step notes become the captions. It does not listen, and no tool here makes such a file. karaoke shows each caption whole and lights the word being spoken, line shows whole captions, word one word at a time. The captions sit inside the space every place in for leaves free of its buttons, drawn by Chrome on this machine in the fonts and color given and laid over the video in one ffmpeg encode, its sound copied. Writes captioned.mp4, captions.srt, captions.vtt, captions.ass, words.json, sheet.png (captions on their frames, the picture to look at first), safe-zones.png (a frame under each app's buttons) and CAPTIONS.md, which the result shows. For the subtitle files alone, use make_subtitles instead. The captions playbook (makersmcp_playbook) has the whole job. (easycaptionkit 0.1.4, on this machine.)

Inputs: video (required), words (required), box, for, +12 more. Returns: kit, docs, next, tool, +11 more

check_place_limitsCheck videos against each place's limitsA
Destructive
Inspect

Use it when the user wants a video checked against a place's limits, or burned captions against a phone app's safe area. Measures finished MP4 files against each place's published limits without changing them: shape, size, frame rate, length, file size, codecs, and whether the MP4 is whole and laid out as Instagram and YouTube ask. Give it a folder reframe_video made, its formats.json, or one MP4 with the places in for. With captions, the ASS, SRT or WebVTT file burned into the video, it checks their timing, and an ASS file's text against each 9:16 place's safe area. It writes CHECK.md, which the result shows, and check.json. A failed check is a normal result, with what failed and the limit's source. It does not say whether a video may be posted. For loudness, black, still and silent stretches, use check_video instead. The reframe playbook (makersmcp_playbook) has the whole job. (reframekit 0.1.3, on this machine.)

Inputs: target (required), for, out_dir, captions, +1 more. Returns: kit, docs, next, tool, +11 more

check_pwa_screenshotsCheck a web app manifest's screenshotsA
Read-onlyIdempotent
Inspect

Use it when the user wants to know whether a web app's install dialog will show screenshots, or a manifest's screenshots checked. Checks the screenshots a web app manifest lists against Chrome's rules for its richer install dialog, without a browser: which ones a desktop and a phone would show, and what to fix. A failed check is a normal result, with the report as its summary. It takes a pwa/manifest-screenshots.json from take_screenshots as it is; when the check fails for want of screenshots, take_screenshots with pwa makes ones that pass. The screenshots playbook (makersmcp_playbook) has the whole job. (easyscreenshotkit 0.1.3, on this machine.)

Inputs: manifest (required), wait_seconds. Returns: kit, docs, next, tool, +11 more

check_setupCheck the setupA
Read-onlyIdempotent
Inspect

Shows which kits makersmcp has and their versions, the Chrome and the ffmpeg found for them (and ffprobe while launch-film is on), any setting that leads to no program, and where files are saved. Use it when a tool is missing or a kit fails to start. Settings like CHROME_PATH, FFMPEG_PATH and MAKERSMCP_OUT go in this server's entry in the MCP client's settings, and take effect when the client starts it again.

Inputs: no named parameters.

check_videoCheck a videoA
Destructive
Inspect

Use it when the user wants a video checked before it goes out: size, frame rate, length, loudness, blank or frozen stretches, cuts on the beat. Checks any video by measuring it with ffmpeg: size, frame rate, length, black, still and silent stretches, loudness, true peak, clipping, and whether the cuts land on the beat. It writes CHECK.md (pass or fail, with every check), which the result shows, check.json, sheet.png (a frame from each shot) and wave.png (the sound over time). A failed check is a normal result here. It knows no platform, and does not measure file size, codec, bitrate or the space an app's buttons cover. For a place's limits, file size and codecs, use check_place_limits instead. A launch film is 25 frames a second and measures about -14 LUFS as it was rendered. The checks playbook (makersmcp_playbook) has the whole job. (launch-film 0.3.1, on this machine.)

Inputs: film (required), cues, cuts, lufs, +5 more. Returns: kit, docs, next, tool, +11 more

fit_musicFit music to a video's lengthA
Destructive
Inspect

Use it when the user wants a music track made as long as a video, its drop on a moment, or music ducked under a voice. Fits a music track to a video cut: makes it exactly the given length by cutting or looping whole bars, lands its drop on the hit, ends it on a beat, ducks it under a voice and sets its loudness, without changing its tempo or pitch. Writes fitted.wav, mix.wav with a voice (the voice over the ducked music), cues.json (every beat, bar, seam and the hit, in seconds and in frames at fps), seams.png (the picture to show the user) and FIT.md (what was done and where to listen). Given the video, it also writes video.mp4, the video's picture as it was with the track under it and its own sound as video_sound says. A launch film to carry the track is planned with plan_launch_film and music false, so its sound is its effects, and give out_dir a folder inside the film's, like its music/, so the film's folder holds its track. Give cues.json to check_video to check the cuts land on the beat. To read a track's tempo, drop and ending without fitting it, use analyze_music instead. The music playbook (makersmcp_playbook) has the whole job. (musicfit 0.2.2, on this machine.)

Inputs: track (required), length (required), bpm, end, +12 more. Returns: kit, docs, next, tool, +11 more

launch_film_guideLaunch film looks and scene typesA
Read-onlyIdempotent
Inspect

Use it when the user wants the looks of a launch film, or the scene types its plan takes. Lists launch-film's looks and what each one suits (topic looks), or its scene types with their main fields (topic types). It is for picking the look of plan_launch_film or make_launch_film, or for writing film.json, whose clip kinds, each type's other fields and the rules for the words on screen are in the film-json playbook. The launch-film playbook (makersmcp_playbook) has the whole job. (launch-film 0.3.1, on this machine.)

Inputs: topic (required), wait_seconds. Returns: kit, docs, next, tool, +11 more

list_caption_stylesCaption styles and each place's marginsA
Read-onlyIdempotent
Inspect

Use it when the user wants the caption styles, or the margins an app's buttons leave free. Lists easycaptionkit's caption styles with what each suits, its options, and every place's margins, in pixels of the screen or frame they are for, each with its source and the day it was read. It reads no file and runs no browser or ffmpeg. Use it to pick a style and the places for caption_video, or to tell the user where an app's buttons sit. The captions playbook (makersmcp_playbook) has the whole job. (easycaptionkit 0.1.4, on this machine.)

Inputs: wait_seconds. Returns: kit, docs, next, tool, +11 more

list_jobsList jobsA
Read-onlyIdempotent
Inspect

Lists the jobs makersmcp started since it was launched, running or ended, with their folders. Use it after a call that ended with no result, before starting that tool again: the job may be running. Jobs end when makersmcp ends, and a finished job's files stay in its folder.

Inputs: no named parameters.

make_brand_kitBrand kit from a websiteA
Destructive
Inspect

Use it when the user wants a site's logo, colors, fonts or brand guidelines, or to design, build or animate anything for a product whose site is known. Reads a website in a headless browser, the way it is drawn, and saves its brand in one folder: the logo files cut from their real background (PNG and SVG), the colors with where each one is used, the fonts, the first screen, a brand card, and the app store icon and screenshots when the site links to its apps. BRAND.md is the file to read first and card.png the picture to show the user; brand.json is for tools and _brand.yml for Quarto and Shiny. With facts, it also saves what the site claims about itself, each claim with its page, in FACTS.md, for copy that needs the site's numbers, customers, quotes or prices; a launch film does not read it. An App Store or Google Play listing works as the address, a social profile is refused, and a deeper page is read from the home page. For font files and their licenses, use make_font_kit instead. The brand playbook (makersmcp_playbook) has the whole job. (easybrandkit 0.4.2, on this machine.)

Inputs: url (required), facts, stores, out_dir, +2 more. Returns: kit, docs, next, tool, +11 more

make_font_kitFonts of a websiteA
Destructive
Inspect

Use it when the user wants the fonts a site uses, their files and licenses, or free fonts that match a site's type. Reads one page of a website in a headless browser and saves its fonts in one folder: which font draws its headings, body text, buttons and code, every font file the page loads, how each one is licensed, and the closest free font for each one that is not free. FONTS.md is the file to read first, fonts.css is for pages, with a variable for each role, and fonts.json for tools. The license of each font is written next to it so the user can decide what to use. It reads only the page at url, so a font used only on another page needs a run on that page, and a page that answers with an error gets no kit. For a whole brand kit with logos and colors, use make_brand_kit instead. The fonts playbook (makersmcp_playbook) has the whole job. (easyfontkit 0.1.5, on this machine.)

Inputs: url (required), files, out_dir, wait_seconds, +1 more. Returns: kit, docs, next, tool, +11 more

make_launch_filmLaunch film from a websiteA
Destructive
Inspect

Use it when the user wants a launch video, product video, promo, teaser or announcement clip for a product's site or app. Makes a 20 to 40 second launch film from a product's own site in one job: it reads the brand and the page, plans the film (name and promise, the real screen in a browser window, the page's own headline, feature cards, a number the page states when it finds one, the logo close) and renders film.mp4 with music and sound effects, with Chrome and ffmpeg on this machine. Nothing is generated by AI: the film shows what the site says. The result shows film.json, the plan, next to words.json, the page's words, and frames/sheet.jpg has two stills a clip. The film is 25 frames a second at 1920x1080 or 1080x1920, its sound about -14 LUFS. Its music is the look's own, or a track of the user's that film.json names. For the user's own track, plan with music false and give the rendered film to fit_music as video. For a plan to read or change before it renders, use plan_launch_film instead. The address needs a dot in its host name, so localhost on its own is refused. The launch-film playbook (makersmcp_playbook) has the whole job. (launch-film 0.3.1, on this machine.)

Inputs: url (required), sfx, jobs, keep, +8 more. Returns: kit, docs, next, tool, +11 more

make_launch_stillsLaunch picturesA
Destructive
Inspect

Use it when the user wants Product Hunt gallery images and thumbnail, an og:image, an X post image, a Google Play feature graphic or Chrome Web Store tiles. Makes the pictures a launch needs at the exact size each place asks for, as opaque PNGs in stills/, listed in STILLS.md, which the result shows. ph makes ph-1.png (the logo, the promise and the screen) and up to 5 of the film's scenes from ph-2.png on, all 1270x760, and ph-thumbnail.png at 240x240; og makes og.png at 1200x630; x makes x.png at 1600x900; play makes play-feature.png at 1024x500, Google Play's feature graphic only; chrome makes chrome-small.png at 440x280 and chrome-marquee.png at 1400x560. The words and the look come from a film.json, the logo from the brand and the screen from the site; no picture is 9:16. Given a site instead of a film.json, it plans a film first with the default look, length and aspect. For App Store or Google Play screenshots, use take_screenshots instead. The launch-film playbook (makersmcp_playbook) has the whole job. (launch-film 0.3.1, on this machine.)

Inputs: source (required), for, out_dir, wait_seconds. Returns: kit, docs, next, tool, +11 more

makersmcp_playbookMakersMCP playbooksA
Read-onlyIdempotent
Inspect

Returns MakersMCP's playbooks. Each covers one kind of job for the kits on this server: the order of calls, the arguments that matter, what to check and what to hand over. Before a job with more than one step, like a launch film, music fitted to a video or a launch kit, or when unsure which tool fits a request, read its topic and wait for it before any other call: the topic can change the job's first call. Each topic is complete for its job, and up to three can be read in one call. Topics:

  • getting-started: which tool fits which request, how jobs, waits and files work, and what the kits do not make

  • launch-kit: the files a launch needs, made in order across the kits, with the place map and what to hand over

  • brand: make_brand_kit: logo files, colors, fonts, first screen, store assets and the site's own claims

  • fonts: make_font_kit: the fonts a page draws with, their files and licenses, the closest free fonts

  • screenshots: take_screenshots and check_pwa_screenshots: pages, store and gallery sizes, themes, manifest screenshots

  • demo-video: record_demo_video: a tour or a steps file, the timing in steps.json, what comes after

  • launch-film: make_launch_film, plan_launch_film, render_launch_film, make_launch_stills: the film and its pictures

  • film-json: film.json, the plan of a launch film: clips, scene types, the words on screen and their rules

  • checks: check_video: what to expect of each video, cuts on the beat, reading CHECK.md and the sheet

  • music: analyze_music and fit_music: a track fitted to a film or a demo and laid under it, the hit, a voice

  • reframe: reframe_video, plan_reframe and check_place_limits: each place's shape, length and size, the crop, the checks

  • captions: caption_video, make_subtitles, list_caption_styles: captions in the brand's fonts, subtitle files, app margins

  • jobs-and-files: long jobs, calls that end early, cancelling, folders, passing one job's files to the next

  • troubleshooting: setup, the errors the tools return and their fixes, the kits' flag names

Inputs: topics (required).

make_subtitlesSubtitle files from words with timesA
Destructive
Inspect

Use it when the user wants an SRT, VTT or ASS subtitle file for a video. Writes subtitle files from words with times the user already has, and changes no video: captions.srt and captions.vtt, lines of up to 42 characters for any player or place that takes a captions file, captions.ass with the font, the colors and the place, laid out for the frame of the video given (else a phone's for tiktok, reels or shorts, a square for square alone, and 16:9 for the rest), and words.json, captions.json and CAPTIONS.md, which the result shows with how fast the captions read. The words are a speech-to-text JSON, an SRT or WebVTT file, or a demo's steps file, whose step notes become the captions; without video, a demo's captions end where its steps file says the video does. To burn the captions into the video, use caption_video instead. The captions playbook (makersmcp_playbook) has the whole job. (easycaptionkit 0.1.4, on this machine.)

Inputs: words (required), box, for, font, +11 more. Returns: kit, docs, next, tool, +11 more

plan_launch_filmPlan a launch filmA
Destructive
Inspect

Use it when the user wants to choose a launch film's look, length or words, or to read its plan before it renders. Reads a product's brand and page and writes film.json, the plan of a launch film, without rendering it. The result shows film.json, words.json (the page's words) and brand/BRAND.md, so every word on screen can be checked against the page before the render. Change film.json where it is wrong (launch_film_guide with topic types lists the scene types), then render it with render_launch_film. A second aspect is a second plan with words from the first and the other aspect. For a film in one job, use make_launch_film instead. The launch-film playbook (makersmcp_playbook) has the whole job. (launch-film 0.3.1, on this machine.)

Inputs: url (required), sfx, look, brand, +6 more. Returns: kit, docs, next, tool, +11 more

plan_reframePlan each place's cropA
Destructive
Inspect

Use it when the user wants to see a video's crop for each place before it renders. Plans what reframe_video renders, without rendering: finds the shots of a finished video and, for each place's shape, a window that follows what moves in each shot, or a padded shot where a crop would cut too much. Writes crop.json, every shot with its window for each shape, sheet.png, each shape's window drawn on every shot's frames (a solid outline for a crop, a dashed one for a padded shot), with more shots in sheet-2.png and on, and FORMATS.md, which the result shows with the command that renders the plan. Look at the sheet, move a window that misses in crop.json, then give that crop.json to reframe_video as crop. A plan in a folder of an earlier render keeps its files. For the files themselves in one job, use reframe_video instead. The reframe playbook (makersmcp_playbook) has the whole job. (reframekit 0.1.3, on this machine.)

Inputs: video (required), for, fps, pad, +11 more. Returns: kit, docs, next, tool, +11 more

record_demo_videoDemo video of a websiteA
Destructive
Inspect

Use it when the user wants a demo video, a walkthrough, a GIF of a site, or footage of the real site for a video. Records a short demo video of a website: a tour of the pages worth showing, or the steps in a file. The page plays in a browser window on a backdrop, with a visible pointer, smooth scrolling and a zoom on each click; cookie banners and chat bubbles are hidden, never clicked. Saves demo.mp4 (1920x1080, H.264, no sound), demo.gif, poster.png, the picture to show first, and steps.json: each step's start and end, and each click's moment as pressedAt, which music and captions are timed from. A steps file's targets are CSS selectors or text=, and pages and page are for a tour only. A tour gives a page about 4 to 8 seconds. For still screenshots, use take_screenshots instead. The demo-video playbook (makersmcp_playbook) has the whole job. (easyscreenshotkit 0.1.3, on this machine.)

Inputs: url (required), fps, gif, hide, +13 more. Returns: kit, docs, next, tool, +11 more

reframe_videoA video in each place's shapeA
Destructive
Inspect

Use it when the user wants a video for TikTok, Reels, Shorts, YouTube, X or LinkedIn: vertical, square or 4:5, or cut to a place's length or size. Turns one finished video into the version each place takes, with ffmpeg on this machine: 9:16 for TikTok, Reels and Shorts, 4:5 for the feeds, 1:1, and 16:9 for YouTube, X and LinkedIn. In each shot the crop follows what moves, not faces, and a shot whose action or words are wider than the crop is padded, shown whole on a blurred copy of itself. Each file is cut at a shot change to its place's length, kept under its size limit, set to the loudness asked for, given a cover beside it and checked against the limits the place publishes. FORMATS.md, which the result shows, lists every file with its checks; sheet.png, the picture to show first, draws each shape's window on every shot. A launch film's timeline or a demo's steps file beside the video gives its shots. To move a window, plan first and edit crop.json. For a look at the windows before anything renders, use plan_reframe instead. The reframe playbook (makersmcp_playbook) has the whole job. (reframekit 0.1.3, on this machine.)

Inputs: video (required), for, fps, pad, +11 more. Returns: kit, docs, next, tool, +11 more

render_launch_filmRender a launch filmA
Destructive
Inspect

Use it when the user wants a film.json rendered into film.mp4, after a plan or a change. Renders a film.json into film.mp4 next to it, with Chrome and ffmpeg on this machine, and writes film.timeline.json, each clip's start and length, which the result shows. It replaces the film.mp4 and film.timeline.json of an earlier render there and does not draw frames/ again. check_video makes a new sheet.png to look at. The film is 25 frames a second. Rendering a 30 second film takes one to three minutes. The launch-film playbook (makersmcp_playbook) has the whole job. (launch-film 0.3.1, on this machine.)

Inputs: film (required), jobs, keep, wait_seconds. Returns: kit, docs, next, tool, +11 more

take_screenshotsScreenshots of a websiteA
Destructive
Inspect

Use it when the user wants screenshots of a site, App Store or Google Play screenshots, Product Hunt gallery images, or a web app manifest's screenshots. Opens a website in a headless browser, picks the pages worth showing (home, pricing, features and the like), hides cookie banners, chat bubbles and other floating boxes, and saves desktop, phone and whole-page screenshots in one folder. sheet.png, every page on one picture, is the picture to show first; SCREENSHOTS.md lists each page with why it was picked, its files and its headings. url and page are pages of one public site: a #route, like /app/#/plants, opens that view of a web app, nothing behind a login is reached, and above one page it starts at the site's root. clean hides everything fixed on the screen but a top bar and a side bar, so an app's own tab bar too. iphone is 1320x2868, the App Store's 6.9 inch size; mobile is 1080x1920, for Google Play phones. For the Google Play feature graphic and Chrome Web Store tiles, use make_launch_stills instead. For a view behind a click, use record_demo_video with steps. The screenshots playbook (makersmcp_playbook) has the whole job. (easyscreenshotkit 0.1.3, on this machine.)

Inputs: url (required), pwa, hide, lang, +9 more. Returns: kit, docs, next, tool, +11 more

wait_for_jobWait for a jobA
Read-onlyIdempotent
Inspect

Waits for a job a makersmcp tool started and returns its result once it ends. It also returns a finished job's result again. If it is still running, call this again with the same job_id. Never start the original tool again to check on a job: that starts a second one. A call that ended with no result may still have started a job: list_jobs shows it.

Inputs: job_id (required), wait_seconds. Returns: kit, docs, next, tool, +11 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 24 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count4/5

    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.

    Completeness4/5

    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.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      A local stdio MCP server that enables coding agents to find licensed photos and icons, generate color palettes and simple SVG assets, and preview static web prototypes. It also supports editable agent skills for design and prototype review workflows.
      23
      2
      MIT
    • A
      license
      B
      quality
      B
      maintenance
      Enables AI assistants to inspect, convert, resize, crop, merge, extract and OCR local images, PDFs, audio and video entirely on the user's machine. Modules can be toggled individually, and all operations stay within a sandboxed working folder with atomic writes and no data sent anywhere.
      21
      MIT