comfyui-mcp

apply_manifest

Set up a ComfyUI environment by applying a manifest that installs custom nodes, downloads models, and installs pip packages from an inline object, JSON/YAML file, or bundled pack.

Instructions

Apply a ComfyUI setup manifest from an inline object or .json/.yaml/.yml file. Composes custom-node installs and model downloads, installs pip packages, and reports apt entries as skipped (system packages need manual/root installation). LOCAL ComfyUI: model downloads use the connected server's live/data model roots; pip uses the serving checkout (live main.py root, then COMFYUI_CODE_PATH, then COMFYUI_PATH); filesystem custom-node fallbacks use the live data/base root (live --base-directory, then COMFYUI_PATH). REMOTE ComfyUI: custom_nodes and models are routed through the ComfyUI-Manager HTTP API (handled on the host), while pip and apt entries are reported as skipped (no remote equivalent). Each item reports applied/skipped/failed/pending independently. success is true only when nothing failed AND nothing is still pending. A PARTIAL INSTALL (custom_nodes left unsubmitted when the time budget elapsed) is named in the partial field — a drained Manager queue / panel_node_queue_status does not include those entries; re-run apply_manifest to submit them. Do not restart ComfyUI until they report applied or skipped.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "apply_manifest"
  }
}

Input Schema

Name	Required	Description
`pack`	No	A bundled installer pack by NAME, as reported by list_packs (action:"list"). PREFER THIS over `path` for a bundled pack: the name is resolved against the running build at apply time, while a manifest_path captured earlier points into an npx cache directory that a later respawn no longer has (#1568). Provide exactly one of `manifest`, `path`, or `pack`.
`path`	No	Path to a .json, .yaml, or .yml manifest file. Provide exactly one of `manifest`, `path`, or `pack`.
`manifest`	No	Inline manifest object. Provide exactly one of `manifest` or `path`.

Schema Changelog

Changes observed during successful MCP inspections.

First observedv1.0.0Sep 30, 2026

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full responsibility, and it delivers: it discloses success semantics ('success is true only when nothing failed AND nothing is still pending'), partial-install behavior in the partial field, the Manager-queue caveat, local path resolution order, and remote routing through ComfyUI-Manager. This is detailed, non-obvious behavior that an agent needs to know before invoking.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is dense but every clause earns its place: it covers input forms, item categories, local/remote path behavior, per-item statuses, success criteria, partial installs, and the restart warning. It is not a terse two-liner, but the complexity of the tool justifies the length and the information is grouped logically; only minor trimming of repeated 'LOCAL/REMOTE' details would improve it.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

This is a complex tool (nested manifest object, local vs remote modes, multiple item types, partial-failure states) with no output schema, yet the description covers what happens per item, how success is computed, what partial installs look like, and what follow-up action is needed. That makes the description sufficient for an agent to apply the tool correctly and interpret its result.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3; each parameter (pack, path, manifest) is already documented in the schema. The prose adds file-format context and environment-dependent resolution behavior, but it does not substantially enrich individual parameter semantics beyond what the schema and its param descriptions already provide.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific action and resource: 'Apply a ComfyUI setup manifest from an inline object or .json/.yaml/.yml file.' It then enumerates what the tool composes (custom-node installs, model downloads, pip packages, apt entries as skipped), making the tool's scope unambiguous and distinguishing it from single-purpose siblings like download_model or install_custom_node.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear operational guidance: local vs remote behavior, why some entries are skipped, and the warning not to restart ComfyUI until entries settle. It also indirectly signals when apply_manifest is appropriate (bulk manifest application) but does not explicitly name alternative tools or carve out when-list_packs/install_custom_node should be used instead, so it stops short of full exclusion guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.