M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
K

Kinocut

Community
Guardrailed video editing MCP server for AI agents
How to install ↓ Compare GitHub source repository ↗
Category
Other #30 of 230
Stars
★ 210 Very popular
Transport
stdio (local process)
Runtime
Python 3.11+ · Prebuilt binary · Node.js 22+
Credentials
No credential needed
License
Apache-2.0
Last commit
Tools
19
66FMRS · C

Kinocut is a local-first, Apache-2.0 video editing MCP server that wraps FFmpeg in typed tools with preflight guardrails, Video Receipts, and quality/release checkpoints, letting AI agents trim, caption, repurpose, and quality-gate media on the local machine. Its clear strengths are being free, account-free, and local so media stays on the user's machine, with an emphasis on inspectable, traceable outputs; the trade-offs are the local FFmpeg requirement (plus Node.js and large optional extras for some features) and the explicit expectation that a human reviews audio and video before publishing. Several README surfaces are labeled unreleased or gated, so check the version and status notes before relying on them.

Strongest · Documentation 16/20 Weakest · Reliability 10/20

Reliability
10/20
Security and permissions
11/20
Maintenance
15/20
Documentation
16/20
Setup experience
14/20
Why each score
Reliability 10/20
Static material shows a local stdio server declared in server.json as PyPI package kinocut 1.15.1 with uvx runtimeHint, and the README documents concrete diagnosability work: a `kino doctor` check that imports the same server tree used by `--mcp`, honest MCP startup failure reporting, a golden path script, and receipt-backed workflow provenance. That said, nothing in the supplied source is verifiable execution evidence — no CI workflow file, no committed test files, and no server-side tool list to compare against the claimed 196/201 MCP tools, so declared behavior cannot be confirmed against real behavior. The README also mixes 'published 1.15.1' and 'development tip' counts (196/201, 167/172) and self-describes several surfaces as gated or unreleased. Under the static calibration cap of 12 for absence of verifiable execution evidence, and with these residual contradictions, the score is reduced to 10.
Security and permissions 11/20
The server is described as local-first, Apache-2.0, with no account or API key for the core surface and no upload of media to a vendor cloud; high-risk edit paths are stated to run preflight guardrails and publication flows are fail-closed with human review. I found no malware, credential theft, covert exfiltration, irreversible default destructive actions, fabricated maintainer identity, or install examples containing real secrets, so no red line is triggered. Deductions: it shells out to an external FFmpeg process without a documented sandbox or argument allowlist; optional extras (Hyperframes/Node, Whisper, C2PA signing, object matte ONNX) expand the dependency and network surface without a least-privilege discussion; a community self-hosting example exposes the server via Tailscale Funnel, Caddy and Google OAuth without a security review; and all permission/confirmation claims are README assertions with no static code evidence. Scored 11 as a mid-upper posture without a red line.
Maintenance 15/20
The manifest and README indicate Apache-2.0 licensing, a current 1.15.1 release, semantic versioning with a changelog, links to CONTRIBUTING, CODE_OF_CONDUCT, GOVERNANCE, SECURITY and SUPPORT, named external contributors with specific PR/issue numbers, and a claimed CI workflow plus release process — suggesting sustained, owned maintenance. Deductions: none of those governance or CI files are present in the supplied source, so their existence and content cannot be verified; the README repeatedly conflates published and development-tip versions and counts, weakening version traceability; the security-response channel is only a link with no described SLA or process; and release dates in the far future are stated without corroborating artifacts. Scored 15 rather than higher.
Documentation 16/20
Documentation is layered and specific: install matrix, golden path, tutorial, comparison and recommendation docs, plus TOOLS, PYTHON_CLIENT, CLI_REFERENCE, WORKFLOWS, RESCUE, 360_ASSEMBLY, AI_VIDEO_*, MCPB and C2PA references. The README supplies copy-paste client configs for Claude Code, Claude Desktop and Cursor, optional-extra sizing, a doctor self-check, a workflow JSON example and a receipt schema, and it discloses real limitations (MCPB is not a sandbox, `.insv` rejected, generative backends off by default, rendered bytes may differ across FFmpeg builds). Deductions: the published-vs-tip tool and CLI counts appear repeatedly in conflicting pairs, which can mislead a reader about current capability; most referenced docs/ files are not included in the supplied material so their content cannot be cross-checked; and tool parameter and error-code details are deferred to external files. Scored 16 as usable with some hidden assumptions.
Setup experience 14/20
The install path is clear: install FFmpeg first (brew/apt commands given), then `pip install kinocut` or `uvx --from kinocut kino doctor`, with directly copyable MCP configs for Claude Code (one-line command), Claude Desktop and Cursor; optional extras are listed with approximate sizes; `kino doctor` self-verifies features; and startup failures now report their real cause. Cross-platform support (macOS, Linux, Windows) is declared with Node 22+ required for Hyperframes. Deductions: FFmpeg and ffprobe must already be on PATH; the changelog shows recurring Windows path-escaping and console-encoding issues, implying setup is not consistently one-shot; the MCPB path depends on an existing Node/Python/FFmpeg stack and is explicitly not a sandbox; and no CI or test files are present to statically confirm the steps work. Under the static setup cap of 15, scored 14.

Static review · not runListed 2026-09-10

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesRuns commands or code

Best for

  • AI agent builders who want local video editing, captioning, repurposing, and quality gating
  • Developers and creators already using MCP clients such as Claude Code or Cursor
  • Local media operators who want typed, guardrailed FFmpeg operations with traceable artifacts instead of guessed flags

Not for

  • Users who want a hosted cloud editor or credit-metered SaaS
  • Users who want an untyped shell wrapper for arbitrary FFmpeg commands
  • Anyone unwilling to install FFmpeg (and optionally Node.js, Whisper, and other extras) locally
  • People expecting to edit raw Insta360 .insv or GoPro .360 files directly — you must export a stitched equirect MP4 from the camera app first

Required permissions

  • Read and write local media files and output directories (editing, exporting, receipts)
  • Execute local FFmpeg/ffprobe subprocesses
  • Read local project/data directories (for example the ~/.mcp-video compatible data dir)
  • Optional: network access for Hyperframes features, website capture, or installing Python extra dependencies
  • Optional: C2PA signing requires c2patool plus a local manifest/signer

Risks and side effects

  • Agents may produce poor or broken video: the README explicitly requires video_quality_check, release checkpoints, and human visual/audio inspection before publishing
  • Risk of overwriting source media: rescue and derivative flows claim the source stays immutable, but you should still back up important footage
  • Optional extras are large (transcribe ~1 GB, stems ~2 GB, upscale ~2 GB), consuming significant disk and install time
  • Depends on a local external toolchain (FFmpeg, plus Node.js 22+ for Hyperframes), so environment drift causes failures
  • Optional capabilities such as website capture, local speech, or AI background removal may involve network access and extra licensing/compliance review
  • Some README surfaces (desktop MCPB packaging, deeper Sonic World Audio integration, the trusted execution kernel, generative spend-cap plans) are gated, partial, or unreleased and should not be treated as stable shipped features

Setup

Before you start

Runtime：Python 3.11+ · Prebuilt binary · Node.js 22+

Other optional settings (1)
MCP_VIDEO_HYPERFRAMES_COMMAND optional Path to a resolvable Hyperframes CLI; only needed for Hyperframes tools when the CLI is not on PATH.
  1. Install FFmpeg and make sure it is on PATH: brew install ffmpeg on macOS, or sudo apt install ffmpeg on Ubuntu/Debian.
  2. Install Kinocut: pip install kinocut.
  3. Run diagnostics: kino doctor and confirm required checks pass.
  4. Register the server with your MCP client. For Claude Code: claude mcp add kinocut -- uvx --from kinocut kino. For Claude Desktop or Cursor, use a config such as {"mcpServers":{"kinocut":{"command":"uvx","args":["--from","kinocut","kino"]}}}.
  5. Optionally install extras you use, e.g. pip install "kinocut[transcribe]" for speech-to-text (about 1 GB). Hyperframes tools additionally need Node.js 22+ and a resolvable Hyperframes CLI.
.mcp.json 
{
  "mcpServers": {
    "kinocut": {
      "command": "uvx",
      "args": ["--from", "kinocut", "kino"]
    }
  }
}

Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "kinocut": {
      "command": "uvx",
      "args": [
        "--from",
        "kinocut",
        "kino"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add kinocut -- uvx --from kinocut kino

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

After installing FFmpeg, run `uvx --from kinocut kino doctor` — required checks must pass. In Claude Code run `claude mcp add kinocut -- uvx --from kinocut kino`, then ask the agent to list tools; video_intent, video_repurpose, and search_tools should appear.

Troubleshooting

  1. Run kino doctor first: it reports exactly which features are available and what is missing
  2. Confirm FFmpeg is installed and on PATH (brew install ffmpeg or sudo apt install ffmpeg)
  3. If MCP startup fails, note that since 1.15.0 the real import cause is printed instead of a vague hint; also check Python 3.11+
  4. Hyperframes tools need Node.js 22+ and a resolvable Hyperframes CLI via PATH or MCP_VIDEO_HYPERFRAMES_COMMAND
  5. Install the matching extra for missing capabilities, e.g. pip install "kinocut[transcribe]" for transcription or kinocut[image] for image analysis
  6. Prove the install with the smallest confidence workflow: python scripts/golden_path.py, or the receipt-backed workflow under workflows/05-confidence-baseline
  7. Upgrading from mcp-video: the mcp_video import, MCP_VIDEO_* env vars, ~/.mcp-video data dir, and legacy receipt keys remain supported on the 1.14.x+ line; new integrations should use kinocut and the kino command

Things to try

Once connected, you can ask your AI assistant things like:

  • Trim this interview to the strongest 45 seconds, add burned captions, make it vertical, and quality-check it before export.
  • Turn this landscape recording into a captioned TikTok video and YouTube Short.
  • Turn this master clip into Shorts, Reels, and TikTok local delivery packages with thumbnails and a manifest.
  • Build a vertical short via a pipeline of trim, add_text, normalize_audio, and resize, then give me the Video Receipt.

Tools 19

video_intent read-only
Express an editing goal as an intent verb and dry-run a plan without mutating media
video_review_run read-only
Run the watching guardrail floor such as blackdetect/LUFS plus a first-15-second inspection
video_review_decide writes
Record a human decision (approve/reject) on a review plan or 360 assembly plan
video_ingest writes
Ingest a source asset into a private content-addressed project
video_preflight read-only
Run preflight validation on a stored asset
video_inspect_temporal read-only
Run temporal inspection on a stored asset and produce an evidence package
video_verdict writes
Write a verdict tied to exact asset identity
video_acceptance_eval read-only
Evaluate acceptance criteria against human evidence
Show 11 more tools
video_body_swap writes
Perform bounded, audio-preserving derivatives such as body swap
video_salvage writes
Repair problem regions using allowlisted salvage recipes
video_workflow_validate read-only
Cheap structural gate on a multi-step workflow job-spec, with no render
video_workflow_plan read-only
Dry-run the operation graph and hashes without rendering
video_workflow_render writes
Execute a multi-step workflow and emit a provenance receipt
video_workflow_inspect read-only
Read-only integrity re-check of a workflow receipt
video_composite_layers writes
Stack ordered image/video/solid layers with opacity, placement, masks, and blend modes
video_repurpose writes
Repurpose one source video into vertical, horizontal, and square delivery packages with manifests
video_quality_check read-only
Run a quality check on an output
video_release_checkpoint writes
Create a release checkpoint with thumbnail and quality gate
search_tools read-only
Discover available operations by keyword without loading every description

Use cases

Turn an interview or podcast into captioned vertical clips with a Video Receipt an agent can re-run and a human can approve
Repurpose one master clip into YouTube Shorts, Instagram Reels, and TikTok packages with thumbnails, storyboards, and manifests
Podcast and interview cuts: find the strongest segment, normalize audio, add chapters, and export
Drive repeatable, reviewable media workflows from CI or scripts (Claude Code, Cursor, or other MCP clients)
Rescue a damaged clip while keeping story and timeline unchanged: diagnose, approve only safe repairs, render, then verify
Match, grade, and gate multi-still packages with establish-locked color cohesion (still-match, still-grade, still-gate)

Supported clients

Claude Code
Claude Desktop
Cursor

Listed from the project's documentation, not tested by this site.

Overview

Kinocut (formerly mcp-video) is a free, open-source, local-first Model Context Protocol server, Python library, and kino CLI. It wraps FFmpeg (plus optional Hyperframes and Whisper extras) in typed tools with preflight guardrails, Video Receipt provenance, and quality/release checkpoints, so agents can trim, caption, repurpose, and quality-gate local video media instead of inventing FFmpeg flags. Per the MCP manifest it ships as the PyPI package kinocut over stdio (uvx --from kinocut kino) under Apache-2.0. The README states published 1.15.1 documents 196 MCP tools and 167 CLI commands, while the development tip registers 201 MCP tools and 172 CLI commands. No Kinocut account or API key is needed for the core surface and media is not uploaded to a Kinocut cloud, but FFmpeg must be installed and on PATH. Note: the repository contains 2 MCP servers; this profile covers only the server at server.json.

Similar servers

BioMCP 75 · B

One binary. One grammar. Evidence from the biomedical sources you already trust.

★ 659 · Tools 11 Compare with this →
Compare with other MCP servers

Source revision 4906e0736483 Data synced 2026-10-19 Read the FMRS scoring method