chutes-media-mcp
Chutes Media MCP lets coding agents discover, describe, and invoke Chutes media models to generate or edit media assets saved directly into the workspace.
List available Chutes models for image, video, music, and speech, with optional kind or text filtering.
Fetch a model’s live cords and input schemas before generation, including editing cords like
img2imgandinpaint.Generate image, video, music, or speech assets using schema-validated payloads.
Edit existing images when supported by a model, referencing workspace files.
Save generated assets under a configurable output directory, defaulting to
./assets/chutes/<kind>/.Return the saved asset path and write a provenance sidecar with model, cord, params, and schema hash.
Preserve existing files unless
overwriteis explicitly set, with workspace-contained path handling.Automatically retry cold-start models and emit progress updates for long video or music jobs.
Use the same capabilities through either the MCP server or the
chutes-mediaCLI.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@chutes-media-mcp generate an image of a futuristic city skyline"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Chutes Media MCP
Generate image, video, music, and speech through Chutes from any coding agent, with the asset saved straight into the project you are working on.

Chutes Media MCP is a Model Context Protocol (MCP) server and command-line interface (CLI) that give coding agents access to Chutes media models. It ships as an MCP server on standard input/output (stdio), a thin CLI for agents without MCP support, and a bundled Agent Skill for the describe-then-generate workflow.
Instead of hardcoding a payload per model, the server fetches the model's live schema and validates each request before spending a GPU call, then writes the asset and a provenance record into your workspace. It works with Claude Code, Cursor, Cline, Windsurf, Codex, OpenCode, and Claude Desktop.
This is an independent community project. It is not affiliated with, sponsored by, or endorsed by Chutes.
Install
Run the server from npm without installing it globally:
npx -y chutes-media-mcpInstall it globally to put both binaries on your path:
npm install -g chutes-media-mcpRegister the server with Claude Code:
claude mcp add chutes-media --env CHUTES_API_KEY=cpk_your_key -- npx -y chutes-media-mcpFor Cursor, Cline, Windsurf, OpenCode, and Claude Desktop, add the mcpServers entry documented in
docs/mcp-and-cli.md. Running from GitHub instead of npm is supported with
npx -y github:TheStreamCode/chutes-media-mcp. Upgrading from 1.x? See
docs/migration-2.0.md.
Related MCP server: ComfyUI MCP Server
Quick start
Create a Chutes API key at chutes.ai and register the server as shown under Install.
Ask your agent for an asset: "Generate a cinematic hero image of a misty mountain range and save it in this project."
The agent discovers a suitable model, reads its live schema, validates the payload, and saves the result under
assets/chutes/image/. The returned path is ready to reference from your code.
The same describe-then-generate flow is available from a shell through the chutes-media CLI. See
docs/mcp-and-cli.md for the tool reference, CLI examples, and image editing.
Features
Four media kinds (image, video, music, speech), plus image editing when a model exposes an edit cord such as
img2imgorinpaint.Live model contract: cords and input schema are fetched at runtime, never hardcoded.
Payload validation against the live schema before any GPU call is made.
Workspace-contained file access; existing assets survive unless
overwriteis explicitly set.A provenance sidecar per asset with model, cord, params, and schema hash.
Automatic cold-start retry with backoff for models that scale to zero.
Progress updates for long video and music jobs.
One shared core, so the MCP server and the CLI behave identically.
Requirements
Node.js 20.3 or newer for the published server and CLI. Node.js 20 is end-of-life; use Node.js 22 or 24 LTS in production.
A Chutes API key.
Contributors using the locked toolchain need Node.js ^20.19.0, >= 22.13.0, or >= 24.
Configuration
Variable | Required | Default | Purpose |
| Yes | none | Chutes API key. Read from the environment; never written to disk. |
| No |
| How the key is sent in |
| No |
| Management API base URL. HTTPS is required except for loopback development; custom endpoints never receive the Chutes API key. |
| No |
| Output directory inside the agent's working directory. A |
| No |
| Warm models up before invoking them. Set to |
| No |
| Retries when a cold model returns |
| No |
| Base backoff between cold-start retries; it grows per attempt. |
| No |
| Maximum response or local input asset size kept in memory. The maximum is |
| No |
| How often progress heartbeats are emitted while a call blocks. |
| No |
| When |
| No |
| Write a |
Generated assets are saved under ./assets/chutes/<kind>/, relative to wherever the agent runs, so
they land inside the project. Output traversal and symlink escapes are rejected, and existing files
are preserved unless overwrite is enabled.
Privacy and security
The API key is read from CHUTES_API_KEY and kept in memory. Credential-bearing requests go only to
HTTPS Chutes hosts, remote asset URLs are screened against private-network destinations, and file
access is contained to the workspace. Query strings and fragments are removed from network-error
messages so signed asset URLs do not end up in logs. The project collects no telemetry. See
SECURITY.md for reporting.
Troubleshooting
A Chutes request returns 401
The key is missing, invalid, or sent with the wrong authentication scheme. Confirm CHUTES_API_KEY
is set for the process that launches the server, then set CHUTES_AUTH_SCHEME to bearer or raw,
whichever differs from the current value.
A model returns 503 no-instances
The model is scaled to zero and Chutes has no instance ready. The server retries automatically;
raise CHUTES_COLD_START_RETRIES and CHUTES_COLD_START_BACKOFF_MS if the delay is too short, or
pick another model of the same kind.
Generation fails with an unknown or rejected parameter
The live model schema changed or the parameter name is wrong. Call describe_media_model again and
rebuild the payload from the current schema. CHUTES_ALLOW_UNKNOWN_PARAMS=true is a temporary
workaround, not a fix.
An asset write is rejected
Every input and output path must resolve inside the current workspace, and an existing file is not
replaced implicitly. Pass the explicit overwrite option (or --overwrite in the CLI) after
checking the target path.
Development
Requirements: Node.js ^20.19.0, >= 22.13.0, or >= 24 with npm.
git clone https://github.com/TheStreamCode/chutes-media-mcp
cd chutes-media-mcp
npm ci
npm run check
npm run verify:mcp
npm run release:checknpm run check runs the format check, lint, type check, coverage tests, and the build.
npm run verify:mcp starts the built stdio server with a placeholder key and validates the MCP
handshake, the instructions and the three tool definitions without calling Chutes. npm run release:check keeps package.json, CHANGELOG.md, CITATION.cff and server.json on the same
version.
CONTRIBUTING.md covers the Windows path caveat and the opt-in live tests.
Support
Ask usage questions in GitHub Discussions,
report reproducible defects in GitHub Issues,
and report vulnerabilities privately as described in SECURITY.md.
Contributing
See CONTRIBUTING.md. Pull requests must pass the required CI checks.
License
MIT — see LICENSE. Third-party notices are in NOTICE.
Maintained by Michael Gasperini (Mikesoft). If this project is useful to you, consider sponsoring its maintenance.
Available Tools
3 toolsdescribe_media_modelDescribe a Chutes media modelARead-onlyIdempotent
Fetch a model's live cords and input schemas so you can compose a valid request. ALWAYS call this before generate_media for an unfamiliar model. Returns every cord (e.g. generate, and img2img/inpaint when present) with its required fields, types, defaults and a minimal example payload.
Inputs: model (required). Returns: kind, cords, model, tagline, +2 more
generate_mediaGenerate media with ChutesADestructive
Run a generation and save the asset into the workspace. params is the payload you composed from describe_media_model. For editing, params may reference workspace file paths (e.g. image, mask) which the server reads and encodes. The asset is saved under output_dir (default ./assets/chutes//) and the saved path is returned. Long video/music jobs block with progress updates.
Inputs: kind (required), model (required), params (required), cord, +4 more. Returns: cord, cost, kind, path, +6 more
list_media_modelsList Chutes media modelsARead-onlyIdempotent
List available Chutes media-generation models (image / video / music / speech), optionally filtered by kind or a free-text query. Use this to discover a model, then call describe_media_model before generate_media.
Inputs: kind, limit, query. Returns: count, models
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
The three tools form a clear discovery-to-execution pipeline: list models, inspect a model's schema, then generate. Each has a distinct purpose and the descriptions explicitly guide sequencing, leaving little room for misselection.
All tool names use consistent snake_case with verb-led phrasing: list_media_models, describe_media_model, generate_media. The pattern is predictable and readable throughout.
Three tools are well-scoped for a media-generation workflow: discovery, schema inspection, and generation. Each tool earns its place, and the set avoids unnecessary surface area.
The core workflow is covered: list models, inspect live schemas, and generate/save assets with progress updates. Minor gaps exist around asset management or job cancellation/status, but the main generation lifecycle is complete enough for agents to work with.
Maintenance
Related MCP Connectors
Generate images, video and audio from your agent. Every output is kept as an asset in your project.
Generate images, videos, voiceovers, and captions from a chat prompt.
Create and edit images and video, generate music, and retrieve existing audio projects.
Create AI images and videos, manage projects and credits, and use workspace campaign context.
Related MCP Servers
AlicenseAqualityFmaintenanceEnables AI video and image generation through the Runway API. Supports video generation from images and text prompts, image creation, video upscaling and editing, and task management.716 npm23MIT- AlicenseNot gradedqualityDmaintenanceGenerate and refine AI images/audio/video through natural conversation.412Apache 2.0
- AlicenseAqualityCmaintenanceEnables agents to generate images, video, audio, and documents via AihubMax API, with task management and media analysis capabilities.14MIT

Popcraft MCPofficial
AlicenseNot gradedqualityBmaintenanceEnables AI agents and MCP clients to generate and edit video, images, 3D, music, and sound effects, upload or reuse media, preview credit costs, and follow production workflows through a single hosted connector.MIT