에이전트가 무음 구간 제거, 텍스트 기반 편집, 자막 추가를 수행하고 편집 프로젝트를 전문 영상 편집 소프트웨어로 내보낼 수 있는 AI 기반 비디오 에디터입니다.
다른 이름 MakeMyClip/editor, editor, @makemyclip/editor
- 스타
- 11
- Tools
- —
- 다운로드, 30일
- —
- 최신 버전
- 0.5.1
- 마지막 커밋
- 2026년 11월 13일
- 라이선스
- MIT
MakeMyClip Editor MCP란?
MakeMyClip Editor은(는) MCP server입니다. 에이전트가 무음 구간 제거, 텍스트 기반 편집, 자막 추가를 수행하고 편집 프로젝트를 전문 영상 편집 소프트웨어로 내보낼 수 있는 AI 기반 비디오 에디터입니다.
프로젝트 README에서 생성된 요약
MakeMyClip Editor MCP server 정보
MakeMyClip Editor는 AI 에이전트를 사용하는 개발자와 크리에이터가 자연어 대화를 통해 비디오를 편집할 수 있게 해줍니다. 이 오픈 소스 도구는 FFmpeg와 whisper.cpp를 사용하여 로컬 머신에서 비디오 프로젝트를 관리합니다. Claude Desktop 또는 Cursor와 같은 클라이언트용 MCP server로 작동하며, Claude Code skill 및 CLI로도 사용할 수 있습니다. 모든 작업이 사용자의 하드웨어에서만 실행되므로 클라우드 업로드, 계정, API 키가 필요하지 않습니다.
사용자는 무음 구간 제거, 텍스트 변환 결과에서 특정 단어 잘라내기, 반복된 테이크 삭제와 같은 복잡한 편집 작업을 수행할 수 있습니다. 이 서버는 자막을 삽입하거나 타이틀 카드를 생성하는 도구를 제공합니다. 초기 자동 편집이 완료되면 결과물을 mp4로 내보내거나 Final Cut Pro, DaVinci Resolve, Premiere Pro용 전문 프로젝트 파일로 내보낼 수 있습니다. AI 기반 자동화와 전문적인 수동 편집 사이를 연결하는 이 도구는 모든 변경 사항을 비파괴 타임라인에 기록하여 실행 취소(undo) 및 다시 실행(redo)을 지원합니다.
활용 사례
- 1토킹 헤드 녹화본 정리에이전트에게 명령하여 원본 영상 파일에서 일시 정지 구간을 제거하고, 반복된 테이크를 삭제하며, 자막을 추가합니다.
- 2제품 시연 영상 제작여러 개의 화면 녹화 영상을 타이틀 카드 및 특정 재생 시간과 함께 하나의 완성된 영상으로 결합합니다.
- 3편집 품질 검증컷 편집으로 인해 말이 잘릴 수 있는 특정 지점을 식별합니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
MakeMyClip Editor MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 MakeMyClip Editor MCP 설치
$ claude mcp add editor -- npx -y @makemyclip/editorCursor에 MakeMyClip Editor MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"editor": {
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}VS Code에 MakeMyClip Editor MCP 설치
.vscode/mcp.json
{
"servers": {
"editor": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}VS Code CLI에 MakeMyClip Editor MCP 설치
$ code --add-mcp '{"name":"editor","type":"stdio","command":"npx","args":["-y","@makemyclip/editor"]}'Claude Desktop에 MakeMyClip Editor MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"editor": {
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}Codex에 MakeMyClip Editor MCP 설치
$ codex mcp add editor -- npx -y @makemyclip/editorCodex config.toml에 MakeMyClip Editor MCP 설치
~/.codex/config.toml
[mcp_servers.editor] command = "npx" args = ["-y", "@makemyclip/editor"]
Gemini CLI에 MakeMyClip Editor MCP 설치
$ gemini mcp add -s user editor npx -- -y @makemyclip/editorGemini settings.json에 MakeMyClip Editor MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"editor": {
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}구성
MAKEMYCLIP_FFMPEG_PATHOptional: an FFmpeg to use instead of the one ffmpeg-static downloads.
MAKEMYCLIP_WHISPER_MODELOptional: a whisper.cpp model file (e.g. ggml-base.en.bin) for transcripts and captions.
MAKEMYCLIP_WHISPER_PATHOptional: the whisper-cli binary, when it isn't on PATH.
MAKEMYCLIP_WORKSPACEFolder the editor may read and write; put your videos here. Defaults to a folder in the temp directory.
| 이름 | 설명 | 유형 |
|---|---|---|
| MAKEMYCLIP_FFMPEG_PATH | Optional: an FFmpeg to use instead of the one ffmpeg-static downloads. | |
| MAKEMYCLIP_WHISPER_MODEL | Optional: a whisper.cpp model file (e.g. ggml-base.en.bin) for transcripts and captions. | |
| MAKEMYCLIP_WHISPER_PATH | Optional: the whisper-cli binary, when it isn't on PATH. | |
| MAKEMYCLIP_WORKSPACE | Folder the editor may read and write; put your videos here. Defaults to a folder in the temp directory. |
자동 검사
2026년 11월 12일에 실행됨전체 보고서 →자동 검사를 통과했습니다. 이는 보안 감사가 아닙니다. 코드를 직접 읽고 서버에 필요한 최소한의 권한만 부여하십시오. 검사 방식
- 소스 저장소 연결 및 접근 가능통과
- 오픈 소스 라이선스 (OSI)통과
- 최근 1년 내 커밋 또는 릴리스통과
- 패키지 이름이 인기 패키지와 유사하지 않음통과
- 원격 엔드포인트가 HTTPS 사용검사되지 않음
- 파괴적인 도구에 라벨 표시됨검사되지 않음
- 모델에 대한 숨겨진 지침 없음통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음통과
README
GitHub에서 보기MakeMyClip Editor is a free, open-source (MIT) video editor that AI agents drive. You ask Claude to edit a recording; it calls the editor's tools, and FFmpeg and a local whisper.cpp do the work on your computer. It ships as a Claude Code skill, the clip CLI, an MCP server, and a browser timeline editor. No cloud upload, no account, no API key, no telemetry, no generative AI.
"Cut the repeated takes and the pauses out of talk.mp4, caption it, and give me a DaVinci Resolve project."
Claude transcribes the recording locally, cuts the earlier take of each repeated phrase and the silences, captions the speech, flags any cut that may clip a word, and writes
talk.fcpxml. Each edit is one undoable step on a timeline you can open in the browser and take over.
What it does
Version 0.4.0 turns a raw talking-head recording into a clean, captioned cut that opens in a pro editor:
| Feature | What it does | CLI |
|---|---|---|
| Remove silence | Cuts the pauses out of a recording, with a sensitivity control and a dry run | clip timeline silence |
| Local transcription | Word-level transcript with timeline times, from whisper.cpp on your machine | clip timeline transcribe |
| Edit by transcript | Cuts a range of words out of a clip | clip timeline cut-words |
| Remove repeated takes | Cuts the earlier take of each phrase said twice in a row | clip timeline remove-retakes |
| Captions | Burned-in captions timed to the words, as short phrases or one word at a time | clip timeline captions |
| Cut check | Flags cuts where a word may be clipped, with a contact sheet of the frames on each side | clip timeline check |
| Export to Final Cut Pro and DaVinci Resolve | FCPXML 1.10 project | clip timeline export --format fcpxml |
| Export to Premiere Pro | Final Cut Pro 7 XML project, captions as .srt files |
clip timeline export --format xmeml |
| Render | mp4 of the finished cut | clip timeline export |
All of it works from chat (the Claude Code skill or the MCP server), the CLI, and the browser UI; the cut check isn't in the UI yet. Every edit is one step on a non-destructive timeline that undo and redo walk through. Underneath sit 19 single-file FFmpeg tools for everything else: trim, split, concat, transitions, text and title cards, zoom/pan, overlay, speed, color, chroma key, stabilize, and render.
Install in 30 seconds
As a Claude Code skill (chat-driven, no global install):
npx skills add MakeMyClip/editor
Or install it as a Claude Code plugin from this repo's marketplace, inside Claude Code:
/plugin marketplace add MakeMyClip/editor
/plugin install makemyclip-editor@makemyclip
As a CLI (for scripts and CI):
npm i -g @makemyclip/editor
clip --help
As a browser UI (dark visual timeline editor):
clip ui # opens http://127.0.0.1:5573
As a Claude Desktop extension (one click, no Node or config file):
- Install FFmpeg:
brew install ffmpegon macOS,winget install Gyan.FFmpegon Windows. - Download
makemyclip-editor.mcpband double-click it, or drag it into Claude Desktop.
Put your videos in the extension's Media folder (by default Documents/MakeMyClip); the editor reads and writes only there. The extension doesn't include FFmpeg (see License): it finds the one Homebrew, MacPorts, winget, Scoop or Chocolatey installed, or you pick it in the extension's settings, along with the optional whisper model.
As an MCP server (drive it from Claude Desktop / Cursor / any MCP client — no API key, on your existing Claude):
// claude_desktop_config.json → "mcpServers"
{
"makemyclip-editor": {
"command": "npx",
"args": ["-y", "@makemyclip/editor", "mcp"],
"env": {
"MAKEMYCLIP_WORKSPACE": "/path/to/your/media",
"MAKEMYCLIP_WHISPER_MODEL": "/path/to/ggml-base.en.bin"
}
}
}
It is listed in the official MCP Registry as io.github.MakeMyClip/editor, so MCP clients that browse the registry can install it from there. The Claude Code skill auto-discovers triggers and shells out via npx -y on demand. The MCP server exposes the timeline tools (show / edit / check / transcribe / undo / redo / export) and a doctor setup check over stdio; media stays confined to MAKEMYCLIP_WORKSPACE, and MAKEMYCLIP_WHISPER_MODEL is only needed for transcription and captions. Everything runs locally and offline — no API key.
Optional: local transcription (for editing by transcript, removing retakes, and captions):
brew install whisper-cpp # macOS; other platforms: https://github.com/ggml-org/whisper.cpp
export MAKEMYCLIP_WHISPER_MODEL=/path/to/ggml-base.en.bin
Download a model such as ggml-base.en.bin from huggingface.co/ggerganov/whisper.cpp, and set MAKEMYCLIP_WHISPER_PATH if whisper-cli isn't on your PATH. The editor never downloads a model itself.
Check your setup:
npx -y @makemyclip/editor doctor # add --json for a machine-readable report
It checks Node, which FFmpeg runs and whether it can draw text and captions, the workspace, a caption font, and the optional whisper.cpp and model, and prints the fix for anything missing. In Claude Desktop or another MCP client, ask "is my setup OK?" and Claude runs the same check.
Quick start: clean up a talking-head recording
In Claude Code (with the skill) or Claude Desktop (with the MCP server), ask:
Clean up talk.mp4: remove the repeated takes and the pauses, add captions, check the cuts, then export an mp4 and a Final Cut Pro project.
The same steps from the CLI:
clip timeline new
clip timeline add-media talk.mp4 # prints the clip id, e.g. clip_ec2f047d
clip timeline transcribe clip_ec2f047d # each word with its time, plus repeated takes
clip timeline remove-retakes clip_ec2f047d # cut the earlier take of each repeated phrase
clip timeline silence clip_ec2f047d # cut the pauses
clip timeline captions # caption every transcribed clip
clip timeline check --sheet cuts.jpg # flag cuts that may clip a word
clip timeline export talk-clean.mp4 # render the cut
clip timeline export talk.fcpxml # or open it in Final Cut Pro / DaVinci Resolve
clip timeline export talk.xml # or in Premiere Pro
A cut splits the clip into pieces: the first keeps its id, and clip timeline show lists the rest, so run silence on each piece you want tightened (in chat, the agent does this for you). clip timeline undo reverses any step.
Another example: a product demo from screen recordings
Five screen recordings → one polished product demo. Type this into Claude Code (or Claude Desktop, via the MCP server):
Import these five recordings. Trim each to the most interesting 8–12 seconds. Add black title cards saying "Demo 1: Inbox", "Demo 2: Search", "Demo 3: Compose", "Demo 4: Calendar", "Demo 5: Reports" between them. Concat in order. Render to 1080p mp4.
The agent runs roughly ingest × 5 → trim × 5 → add_title_card × 5 → concat → render. The final mp4 lands in your workspace folder, every step is appended to session.json, and you can ⌘Z any of it.
Or skip the chat and do it from a script:
clip ingest demo1.mp4
clip trim demo1.mp4 5 20
clip add_title_card demo1-trim.mp4 "Demo 1: Inbox"
clip concat demo1-with-card.mp4 demo2.mp4 demo3.mp4
clip render concat-output.mp4 mp4 23 fast 1920
Same registry, same session log, same output.
All 19 tools
19 tools across 5 categories, four surfaces (Claude Code skill, CLI, browser UI, MCP server), one shared op log.
| Category | Tools |
|---|---|
| Cut & arrange | trim, split, concat, transition (12 kinds) |
| Text & captions | add_text, add_title_card, add_captions |
| Visual primitives | transform, adjust, zoom_pan (Ken Burns), overlay, speed |
| Composites & specialty | highlight_reel, silence_remove, chroma_key, stabilize |
| Output & I/O | ingest, preview, render, add_audio |
Plus four meta-ops not in the registry: snapshot, undo, inspect, delete.
The browser UI is a dark timeline editor: drag-drop import, a monitor (the composited frame at the playhead), an editable timeline (select a clip to trim / split / move / transition / remove, cut its silences, or cut words and retakes from its transcript), captions from transcripts, one-click export (an mp4, or a project for Final Cut Pro, DaVinci Resolve or Premiere Pro), timeline undo/redo, snapshot, and keyboard shortcuts.
Why it exists
Existing tools force a tradeoff that doesn't need to exist:
- iMovie / CapCut / DaVinci Resolve — mouse-and-timeline desktops. Can't be driven by an agent, scripted in CI, or version-controlled.
- Descript — closed-source, cloud-based, rewrites audio with generative AI you can't inspect.
- Runway / Pika / Luma — generate video from text. Useful for VFX, useless for assembling a 90-second demo from recordings you already have.
- Raw FFmpeg — deterministic and free, but the surface is hostile to LLMs: cryptic filter graphs, no session model, no undo, no tool catalog.
MakeMyClip Editor closes the gap: deterministic editing an agent can drive end to end (silence, transcript cuts, captions, export to pro editors) on a timeline it can inspect and a human can open and take over.
Feature matrix
| Feature | MakeMyClip Editor | iMovie / CapCut | Descript | Runway / Pika | Raw FFmpeg |
|---|---|---|---|---|---|
| Agent-driven (chat to edit) | ✅ | ❌ | ⚠️ | ❌ | ❌ |
| Open-source (MIT) | ✅ | ❌ | ❌ | ❌ | LGPL/GPL |
| Local-only (no cloud) | ✅ | ✅ | ❌ | ❌ | ✅ |
| Deterministic output (no AI generation) | ✅ | ✅ | ✅ | ❌ | ✅ |
| Free forever | ✅ | ✅ | freemium | paid | ✅ |
| Programmable CLI | ✅ | ❌ | ❌ | API | ✅ |
| Visual timeline UI | ✅ | ✅ | ✅ | ✅ | ❌ |
| Snapshot & undo | ✅ | ✅ | ✅ | ⚠️ | ❌ |
| Inspectable session log (JSON) | ✅ | ❌ | ❌ | ❌ | ❌ |
| Works as a Claude Code skill | ✅ | ❌ | ❌ | ❌ | manual |
| Stream-copy for lossless cuts | ✅ | ⚠️ | ⚠️ | ❌ | ✅ |
| Zero telemetry | ✅ | ❌ | ❌ | ❌ | ✅ |
Use-case matrix
| Job to be done | MakeMyClip Editor | iMovie / CapCut | Descript | Runway / Pika | Raw FFmpeg |
|---|---|---|---|---|---|
| Trim screen recordings to highlights | ✅ | ✅ | ✅ | ❌ | ✅ |
| Assemble a product demo from N clips + title cards | ✅ | ✅ | ⚠️ | ❌ | ⚠️ |
| Add script-provided timed captions | ✅ | ⚠️ | ✅ | ❌ | ⚠️ |
| Transcribe & edit video by its transcript | ✅ (local whisper.cpp) | ⚠️ | ✅ | ❌ | ❌ |
| Auto-cut silence from a recording | ✅ | ❌ | ✅ | ❌ | ⚠️ |
| Finish the cut in Final Cut Pro, Resolve or Premiere | ✅ | ⚠️ | ✅ | ❌ | ❌ |
| Chroma-key / green-screen compositing | ✅ | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Generate b-roll / VFX shots from a prompt | ❌ | ❌ | ⚠️ | ✅ | ❌ |
| Multi-track audio mixing with effects | ❌ | ⚠️ | ✅ | ❌ | ⚠️ |
| Drive editing from an AI agent in natural language | ✅ | ❌ | ⚠️ | ⚠️ | ❌ |
| Run as a scriptable CI pipeline | ✅ | ❌ | ❌ | ⚠️ (API) | ✅ |
| Long-form (>30 min) with hundreds of clips | ⚠️ | ✅ | ✅ | ❌ | ✅ |
| Edit on Linux / headless / fully offline | ✅ | ❌ | ❌ | ❌ | ✅ |
Legend: ✅ great fit · ⚠️ works but not the best · ❌ doesn't fit.
Honest summary: MakeMyClip Editor is the right pick when you want deterministic, scriptable editing that an AI agent can drive end-to-end. Not the right pick for generative video (Runway), a hosted transcript editor with collaboration and AI voice features (Descript), or a heavy multi-track NLE (DaVinci, Premiere) — though it can hand its cut to one.
Claude Code → skill triggers → npx -y @makemyclip/editor <tool | timeline …>
│
Browser UI → /api/tools/:name · /api/timeline/verbs → registry + verb layer
│
Claude Desktop → clip mcp (MCP server) → timeline verbs
│
▼
Tool handlers (TypeScript)
│
▼
FFmpeg subprocess (args as array, no shell)
│
┌───────────────────────┴───────────────────────┐
▼ ▼
Composition document session.json
(non-destructive timeline, (append-only op log
op-log undo/redo) of every tool call)
Two layers of state, by design. The composition document is the source of truth for assembled edits: a non-destructive, multi-track timeline that clip timeline, the browser UI, and the agent (the Claude Code skill or the clip mcp server) all mutate through one op-aware path, with a coupled op log that powers undo/redo. session.json is an append-only op log of every tool invocation — { id, tool, args, result, timestamp } — written through the same appendOp() path by the single-file tools (clip trim, /api/tools/:name, …); it is the audit trail and recovery layer. Both layers are written through one serialized path, so any combination of human + agent edits stays consistent.
Build a composition end-to-end (CLI shown; the browser UI and the agent — Claude Code or MCP — drive the same document):
clip timeline new # start an empty composition
clip timeline add-media intro.mp4 # ingest + append a clip
clip timeline add-media demo.mp4
clip timeline transition <afterClipId> fade 0.5
clip timeline show # inspect tracks, clips, timings
clip timeline export final.mp4 # compile the document to a render
Every edit is undoable (clip timeline undo / redo, clip timeline log), and clip timeline at <sec> / frame <sec> give an agent read-only eyes on the document. Run clip timeline --help for the full subcommand list.
- Language: TypeScript (Node 24+) and React 19 (browser UI)
- Timeline schema: Zod (shared with the MakeMyClip.com web app)
- Subprocess: execa — args as an array, no shell injection
- FFmpeg: downloaded by
ffmpeg-staticwhen the npm package installs, with aMAKEMYCLIP_FFMPEG_PATHoverride and an installed FFmpeg as the fallback (the Claude Desktop extension always uses an installed one) - Transcription: optional, user-installed whisper.cpp, run as a subprocess
- MCP:
@modelcontextprotocol/sdk— theclip mcpserver (Claude Desktop / any MCP client) - UI: Hono server + Vite + React, plain CSS
Setup & installation
Do I need FFmpeg installed separately?
Not for the npm package, the CLI or the Claude Code skill: ffmpeg-static downloads an FFmpeg build for your platform when the package installs. The Claude Desktop extension is the exception: it doesn't include FFmpeg, so install it first (brew install ffmpeg or winget install Gyan.FFmpeg). For your own FFmpeg build (LGPL-only, custom codecs, hardware acceleration), set MAKEMYCLIP_FFMPEG_PATH to its path and the downloaded binary is ignored. clip doctor shows which FFmpeg runs.
What platforms does it run on?
macOS, Linux, and Windows — anywhere Node 24+ runs. The browser UI binds to 127.0.0.1 and needs no internet connection.
Can I use it without Claude Code?
Yes. The clip CLI and clip ui browser app are first-class surfaces, and clip mcp lets Claude Desktop (or any MCP client) drive it. Claude Code is one of several entry points — the editor is agnostic to which agent (or human) drives it.
Does it require an API key? No — nowhere. The CLI, the browser UI, the Claude Code skill, and the MCP server all run with no API key. Agent-driven editing uses whichever Claude you already run (Claude Code, or Claude Desktop via MCP); the editor itself never calls a language model.
Capabilities & limits
Is it production-ready? This release is feature-complete for local editing — a dark timeline editor (view, edit, preview, export), silence removal, transcript editing, captions, export to Final Cut Pro, DaVinci Resolve and Premiere Pro, 19 single-file tools, an MCP server, and 741 tests passing. The API surface is still pre-1.0 (tool schemas may change in minor ways before 1.0). Use it for real work; pin a version in CI.
What's the maximum video size or duration? No hardcoded limit. FFmpeg streams the file rather than loading it into memory, and the browser UI streams uploads to disk — multi-GB recordings work fine. This release isn't tuned for projects with hundreds of clips or runtime above 30 minutes; for those, drive the CLI directly.
Does it support 4K, HDR, or vertical (TikTok / Reels) formats?
4K and vertical aspect ratios work out of the box — render takes a maxWidth and preserves the source aspect ratio. HDR pass-through works; deliberate HDR-to-SDR tone-mapping isn't a named tool yet.
Privacy & data
Does it send my video files anywhere? No. The editor makes zero network calls — period. The agent runs in Claude Code or Claude Desktop, not inside the editor, so nothing leaves your machine.
Where does it store my files?
In a local workspace folder — $TMPDIR/makemyclip-editor by default; override with MAKEMYCLIP_WORKSPACE. The folder holds input files, output files, composition.json (the timeline), session.json (the op log), and snapshots/. You can version-control the whole folder.
Working with agents
Which AI model does it use? No language model — the agent is whatever you already run: Claude Code, or Claude Desktop / Cursor via the MCP server. They call the editor's tools; the editor executes them deterministically with FFmpeg. Transcription, if you set it up, runs your local whisper.cpp with a model file you download.
How does the agent know which tool to call?
Each tool and timeline verb ships with a Zod input schema (parameter docs inline via .describe()) and a one-line description. The Claude Code skill and the MCP server expose that catalog to the agent; it reads the descriptions, picks a tool, and fills in the arguments.
What if the agent makes a mistake?
Every edit appends to session.json and produces a new output file in the workspace; nothing is destructive. Press ⌘Z to pop the last op; click Snapshot before risky operations to save a named restore point; the entire workspace is a folder you can git init.
License & comparisons
Is it free?
Yes — MIT-licensed, free forever for local editing. No paid tier, no signup, no upsell in the editor. Paid AI-generation features (voice synthesis, music, stock footage) will live on MakeMyClip.com when they ship, behind a separate @makemyclip/generation package.
What's the license situation with FFmpeg?
The MakeMyClip Editor source code is MIT. FFmpeg is a separate program the editor runs as a subprocess, so its license covers the binary, not your application code. The build ffmpeg-static downloads is GPLv3 on Intel Macs, Windows and Linux. On Apple Silicon it is a build with nonfree parts that FFmpeg marks as not redistributable, so the Claude Desktop extension ships no FFmpeg at all. For LGPL-only or custom-build requirements (e.g. iOS App Store), set MAKEMYCLIP_FFMPEG_PATH to your own binary.
How is this different from running FFmpeg directly? FFmpeg is one binary with a complex CLI; MakeMyClip Editor is 19 named tools with typed inputs, a session log, snapshot/undo, a browser UI, and an agent-callable API. You're still running FFmpeg under the hood — but with a catalog any LLM can call, input validation that prevents bad commands, and a log you can inspect or version-control.
What's the relationship between this editor and the MakeMyClip.com website? The editor (this repo) is MIT-licensed, free, local, and limited to deterministic FFmpeg operations. MakeMyClip.com is the separate hosted product where paid AI generation features will live. The two share the timeline schema, so projects move between them.
How do I add my own editing tool?
Add a file in src/tools/<name>.ts exporting a Zod input schema and a handler, register it in src/ui/tool-registry.ts, and the tool becomes available in the CLI and the browser UI's tool picker. See AGENTS.md for conventions.
Questions people ask
Answers describe v0.4.0 (November 2026).
How do I edit a video with Claude Code?
Install the MakeMyClip Editor skill with npx skills add MakeMyClip/editor, then ask Claude Code in plain words, for example "cut the pauses out of talk.mp4 and add captions." The skill runs the clip CLI through npx, edits a timeline document in a local workspace folder, and renders with FFmpeg on your machine. Every edit can be undone.
Is there an iMovie or CapCut for Claude?
MakeMyClip Editor is built for that job: an open-source video editor that Claude drives through a Claude Code skill or an MCP server, with a browser timeline (clip ui) where you can watch and take over. It covers everyday edits (trim, join, transitions, titles, captions, silence removal) but isn't a full desktop editor; for finishing, it exports to Final Cut Pro, DaVinci Resolve or Premiere Pro.
MakeMyClip Editor MCP 질문
MakeMyClip Editor MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add editor -- npx -y @makemyclip/editor를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
MakeMyClip Editor MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
클라우드 업로드나 API 키가 필요한가요?
아니요, 모든 작업은 로컬 환경에서 실행되므로 클라우드 업로드, 계정 생성, API 키가 전혀 필요하지 않습니다.
편집한 내용을 전문 영상 편집 소프트웨어로 내보낼 수 있나요?
네, Final Cut Pro, DaVinci Resolve 또는 Premiere Pro로 내보낼 수 있습니다.
텍스트 변환(Transcription)은 어떻게 작동하나요?
whisper.cpp를 사용하여 사용자의 로컬 머신에서 단어 단위의 텍스트 변환을 수행합니다.
편집을 취소할 수 있는 방법이 있나요?
네, 모든 편집은 비파괴 타임라인에서 단일 단계로 취소할 수 있습니다.