← Back to directory
C

ClipForge MCP Server

Community
Drive ClipForge's keyless short-video pipeline from any MCP client — one sentence or a product link becomes a finished vertical video.
Category
Other #88 of 230
Stars
★ 1.0k Very popular
Transport
stdio (local process)
Runtime
Node.js · Docker
Credentials
Optional API key
License
AGPL-3.0
Last commit
Tools
4
58FMRS · C

ClipForge MCP Server is a community-maintained open-source MCP layer that exposes ClipForge's keyless short-video pipeline (script → free stock footage → free TTS → captions → BGM → FFmpeg compose) to any MCP client. It produces videos without API keys and can generate scripts once an LLM is configured; it is self-hosted, watermark-free and AGPL-3.0. It suits users who want local automated production of vertical selling videos driven by AI assistants, and is not for those needing official support or unwilling to run a local instance and FFmpeg.

Strongest · Maintenance 14/20 Weakest · Reliability 9/20

Reliability
9/20
Security and permissions
10/20
Maintenance
14/20
Documentation
13/20
Setup experience
12/20
Why each score
Reliability 9/20
Static evidence: the README claims a CI workflow (.github/workflows/ci.yml) running lint→test→build, claims 1170+ Vitest cases plus Playwright E2E, and documents pnpm pack/dist desktop packaging; the manifest is internally consistent (stdio transport, npm package [email protected], matching versions, all env vars optional with stated defaults) and shows no contradictions. However, this review only has README/manifest text: no committed CI definition, no test files, no tool list or handler source for the MCP server beyond mcp/server.json. Tool declarations cannot be verified against real behavior, the init/tool-list handshake cannot be confirmed, and error/dependency controllability is unproven. Capped at 12 per the static calibration and reduced further for missing verifiable key-path evidence (initialization, failure modes, retry/timeout semantics).
Security and permissions 10/20
No red line is tripped: no malware, credential theft, covert exfiltration, or unconfirmed irreversible delete/pay/deploy/remote-command defaults. Credential handling is relatively restrained: CLIPFORGE_LLM_API_KEY is marked isSecret=true and is optional, and CLIPFORGE_BASE_URL defaults to localhost:3000, indicating a local-only default; the README emphasizes self-hosting and data staying on-device. Deductions: the server drives a pipeline with paid model calls, FFmpeg composition, external stock/TTS endpoints, and product-link fetching, so the capability surface includes meaningful external network access and side effects, while the materials provide only README prose (no source) for per-tool scope restrictions, pre-spend confirmation, SSRF protections, and download/write boundaries. Fetching product URLs and downloading third-party media to local disk are concrete data flows and write side effects that the manifest does not constrain.
Maintenance 14/20
Evidence: not archived, 0 open issues, semantic version 0.1.4 with a clear per-release note trail, README documenting a v0.8.9x–v0.9.4 iteration history including specific fixes for issues #24 and #28, indicating ongoing defect response and release cadence; AGPL-3.0 license is explicit, the author and sibling projects (Dramake, HotClip) are traceable, and automated image builds via GitHub Packages/CI are claimed. Deductions: stars/popularity are discovery signals only and add nothing; despite the issue-fix narrative there is no visible security-response channel, contributor governance, dependency-update policy, or release-verification artifact; the manifest version (0.1.4) conflicts with the feature versions cited in the README (v0.9.4), indicating muddled version governance.
Documentation 13/20
Documentation is large and layered: bilingual README, TUTORIAL.md/TUTORIAL.en.md step-by-step guides, a CLI command list with per-command parameters, a cost section giving concrete model pricing and the resolution cost multiplier (1080p ≈ 4.5x baseline), a compliance section covering AIGC labeling and ad-law terms, FAQ on the free path and watermarking/commercial use, plus mcp/README.md and skills/README setup prompts. Deductions: server-side MCP documentation in this material is thin — the manifest lists only environment variables, with no tool names, parameters, response shapes, or timeout/failure semantics; installation instructions lean heavily on external links and skill files; the assumption that a ClipForge instance must already be running (default localhost:3000) is stated but buried deep in the main document, so limits on standalone server usability are under-disclosed.
Setup experience 12/20
The install path is clear and short: a single docker run brings the service up on port 3000 with a keyless first video, and the clipforge-mcp npm package uses stdio with no auth and all-optional env vars carrying defaults, so client wiring only needs CLIPFORGE_BASE_URL pointing at the local instance. Deductions: usability depends on the app being started first (pnpm dev / pnpm start or Docker), so the MCP server is not self-contained — an implicit prerequisite; local development mandates pnpm (README states npm install errors out) and a user-installed FFmpeg; no per-client config snippet (Claude Desktop / Cursor, etc.) is provided. Per the calibration rule setup is capped at 15 absent verifiable execution evidence, and is further reduced for the hidden prerequisite and the missing client configuration examples.

Static review · not runListed 2026-09-10

Read the FMRS scoring method →

Fit and risk

What it can accessUses the network

Best for

  • Teams that need self-hosted, watermark-free short-video production with data staying local
  • Developers who want AI assistants (e.g. Claude Desktop, Cursor) to drive the video pipeline
  • Operators producing e-commerce, UGC ad or faceless vertical content
  • Individuals who want a zero-key path using free footage and free TTS first

Not for

  • Enterprise production environments needing official commercial support or SLAs
  • Users expecting high-quality AI-generated visuals and native voiceover with no API keys at all
  • Users unwilling to run FFmpeg, Node or Docker locally
  • Users who want a fully managed cloud service with no local instance

Required permissions

  • Launch a local npx process (clipforge-mcp) over stdio
  • Read environment variables CLIPFORGE_BASE_URL, CLIPFORGE_LLM_BASE_URL, CLIPFORGE_LLM_API_KEY (secret), CLIPFORGE_LLM_MODEL
  • Access the HTTP API of the locally running ClipForge service (default http://localhost:3000)
  • Make network requests to the configured LLM endpoint when set, for script generation
  • Use FFmpeg on the ClipForge instance for local video composition and read/write local data files

Risks and side effects

  • CLIPFORGE_LLM_API_KEY is a secret credential; leaking it lets others consume your model quota
  • When external LLM endpoints or paid AI models are configured, script and asset calls may incur usage-based costs; paid generation is designed not to trigger silently
  • AI-generated content faces platform compliance rules (AIGC labeling, advertising-law banned words); the project enables these defaults but does not replace your compliance responsibility
  • Free footage comes from third-party licensed libraries (e.g. Openverse, Wikimedia, Jamendo); verify each license and keep attribution before commercial use
  • If the local instance is exposed to a network, others may call it and consume your model quota

Setup

Before you start

Runtime:Node.js · Docker

CLIPFORGE_LLM_API_KEY optionalsecret API key for that LLM endpoint, needed only for script generation; get it from your chosen model platform (e.g. DeepSeek, OpenRouter).
Other optional settings (3)
CLIPFORGE_BASE_URL optional URL of the running ClipForge instance, default http://localhost:3000 (start via docker or pnpm dev/pnpm start); set it if not using the default. Optional.
CLIPFORGE_LLM_BASE_URL optional OpenAI-compatible LLM endpoint for script generation only; footage and voiceover are keyless without it.
CLIPFORGE_LLM_MODEL optional LLM model id for script generation (e.g. deepseek-ai/deepseek-v3.2); pick from your LLM endpoint's model list.
  1. Start a ClipForge instance: run docker run -d -p 3000:3000 -v clipforge-data:/data ghcr.io/xixihhhh/clipforge, or run pnpm dev / pnpm start inside the repository.
  2. Add clipforge-mcp to your MCP client config: command npx, args -y [email protected], transport stdio.
  3. Set environment variables as needed: CLIPFORGE_BASE_URL pointing to the running instance (default http://localhost:3000); for AI script writing also set CLIPFORGE_LLM_BASE_URL / CLIPFORGE_LLM_API_KEY / CLIPFORGE_LLM_MODEL (OpenAI-compatible endpoint).
  4. Reload the client, confirm the MCP server is connected, then call the tools to generate videos.
claude_desktop_config.json
{
  "mcpServers": {
    "clipforge": {
      "command": "npx",
      "args": ["-y", "[email protected]"],
      "env": {
        "CLIPFORGE_BASE_URL": "http://localhost:3000",
        "CLIPFORGE_LLM_BASE_URL": "",
        "CLIPFORGE_LLM_API_KEY": "",
        "CLIPFORGE_LLM_MODEL": ""
      }
    }
  }
}

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

.vscode/mcp.json
{
  "servers": {
    "clipforge": {
      "command": "npx",
      "args": [
        "-y",
        "[email protected]"
      ],
      "env": {
        "CLIPFORGE_BASE_URL": "http://localhost:3000",
        "CLIPFORGE_LLM_BASE_URL": "",
        "CLIPFORGE_LLM_API_KEY": "",
        "CLIPFORGE_LLM_MODEL": ""
      }
    }
  }
}

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

Terminal
claude mcp add clipforge -e CLIPFORGE_BASE_URL=http://localhost:3000 -e CLIPFORGE_LLM_BASE_URL= -e CLIPFORGE_LLM_API_KEY= -e CLIPFORGE_LLM_MODEL= -- npx -y [email protected]

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

Check that it works

Start a ClipForge instance first (e.g. docker run -d -p 3000:3000 ghcr.io/xixihhhh/clipforge); the client's tool list should show create_video, compose, clipforge_product_script and clipforge_update_shots. Calling clipforge_product_script with a product link and getting a script back confirms the connection.

Troubleshooting

  1. If tool calls fail, first confirm the ClipForge instance is running and CLIPFORGE_BASE_URL is reachable (default http://localhost:3000)
  2. If script generation errors, check CLIPFORGE_LLM_BASE_URL / API key / model id; note that some platforms use a different chat endpoint path than their asset gateway
  3. Client timeouts can be avoided by using wait:false on compose / create_video for non-blocking submission
  4. If composition is empty or fails, check that FFmpeg is installed locally and that assets downloaded and passed decode validation
  5. For poor output, use clipforge_update_shots for pinpoint shot-level fixes rather than regenerating the whole script

Things to try

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

  • Use clipforge_product_script to write a product-selling script from this product link
  • Use create_video to generate a vertical short video for the topic “home pour-over coffee”
  • Call clipforge_update_shots to revise only shot 3's lines, then compose to render the video
  • Compose the finished project with subtitles and background music using compose

Tools 4

create_video writes
Create a short video directly from one sentence or a product link; supports wait:false to submit without blocking and avoid client timeouts.
compose writes
Run FFmpeg composition on ready script and assets to render the final video; supports wait:false non-blocking submission.
clipforge_update_shots writes
Refine a single shot with one sentence, using gate/QC feedback for pinpoint edits instead of regenerating the whole script.
clipforge_product_script read-only
Paste a product link to generate a selling script directly.

Use cases

Generate a vertical short video from a one-sentence topic inside an MCP client
Turn a product link or product image into a host-style or drama-style selling video
Batch or scheduled (via cron) generation of draft videos for publishing
Import a written script, auto-split into shots, attach free footage and free TTS, and compose
Dubbing and re-composing a script into another language for overseas markets

Supported clients

Claude Desktop
Cursor

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

Overview

ClipForge (formerly "daihuo-jianshou") is an open-source AI e-commerce and UGC short-video generator: upload a product image and it extracts selling points, writes a script, keeps the product image undistorted, and adds footage, voiceover and captions to produce a vertical selling video for Douyin Shop, Kuaishou, Xiaohongshu, WeChat Channels and TikTok Shop; it also supports one-sentence topic videos. Its MCP server (npm package clipforge-mcp, version 0.1.4) exposes that pipeline over stdio (script → free stock footage → free TTS → captions → BGM → FFmpeg compose) to any MCP client. Footage and voiceover work keyless without an LLM, while script generation requires an OpenAI-compatible LLM endpoint. The project is AGPL-3.0 licensed, self-hosted, and keeps data on the local machine. This MCP server is maintained by the project author as a community open-source effort, not an official offering from any platform or model vendor.

Similar servers

BioMCP 75 · B

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

★ 659 · Tools 11 Compare with this →

Source revision 1224b73b9139 Data synced 2026-10-19 Read the FMRS scoring method