Skip to main content
Glama

list_packs

List bundled installer packs that provide one-command setups for ComfyUI model families, including custom nodes, model weights, and ready workflows that run locally on your GPU for free.

Instructions

Bundled ComfyUI knowledge — installer packs, model-family skills, workflow templates — plus the two workflow-readiness checks. Driven by the action parameter:

  • action:"list" — List the bundled installer packs under packs/: one-command setups for a model family (custom nodes + model weights via manifest.yaml) PLUS a ready workflow.json graph. Each entry reports its family/kind, its runtime (these packs are LOCAL-GPU / FREE — they run on the user's own GPU and never spend paid API credits), whether it has a ready workflow + manifest, and the manifest path for install_comfyui apply_manifest. When asked to "set up / build a workflow", PREFER applying the matching pack and loading its ready workflow (panel_load_workflow pack:) over building a generic graph from scratch. Read the ready graph with action:"read_workflow".

  • action:"read_workflow" — Return a bundled pack's ready workflow.json graph by pack name (name; discover names + which packs have a workflow with action:"list"). This is the EXPERT graph for that model family — use it as the source of truth when setting up the family on the user's canvas: recreate it node-by-node with the panel_* tools (panel_add_node / panel_connect / panel_set_widget) so it lands on their live canvas, or enqueue it headlessly. Prefer this over inventing a graph from scratch. Names are validated (no path traversal) and must match an existing pack directory.

  • action:"list_templates" — List CUSTOM-NODE-contributed ComfyUI workflow templates on the connected ComfyUI, grouped by source (each pack's own example_workflows/*.json). Hits the live server's /api/workflow_templates index. SCOPE LIMIT: this endpoint does NOT include ComfyUI's own core bundled templates from the comfyui-workflow-templates package (e.g. "Flux.1 Inpaint") — those are served to the frontend as static assets via a separate code path this action cannot see, so a small/empty result here does NOT mean no official template exists, only that no custom-node pack contributed one. When asked to "set up / build a workflow", check here for a custom-node-contributed starter AFTER checking the bundled skills + installer packs (action:"skill_list" / action:"list"), and also tell the user to check the ComfyUI frontend's own Templates browser directly for core templates, since this action cannot enumerate those. NOTE: this lists what's available; loading a template onto the canvas is done in the ComfyUI frontend's Templates browser (the panel agent cannot load a template graph headlessly yet) — surface the matching template name to the user.

  • action:"check_runtime" — Determine whether a workflow runs on the user's OWN GPU (LOCAL — free) or uses hosted API NODES (PAID api credits). Pass pack (a bundled pack name — always local/free) OR graph (a UI or API/prompt workflow JSON, as object or string). It scans the workflow's node class_types against the connected ComfyUI's API-node set (the same signal list_api_nodes uses) and returns { runtime: 'local'|'api'|'mixed'|'unknown', usesApiNodes, apiNodes[], externalApiNodes[], unknownNodes[] } — 'unknown' means some nodes couldn't be classified (could be paid), so treat it (and 'api'/'mixed') as POSSIBLY PAID; only 'local' is confirmed free. externalApiNodes is the THIRD-PARTY paid kind (a fal.ai-style pack, or any node taking a service credential): those are INSTALLED LOCALLY yet still cost money, billed by that provider on the user's own account with them rather than out of Comfy api credits — so when you ask the user, name the provider, not "Comfy credits" (externalProviders names it when recognised — e.g. ["fal.ai"]; it is absent when the node was flagged only by taking a service credential, which proves it authenticates somewhere but not to whom). ALWAYS call this before building OR loading a non-pack/ad-hoc workflow so you can ASK the user before spending paid API credits — never silently use API nodes.

  • action:"extract_deps" — Analyze a ComfyUI workflow (workflow, API JSON) and determine which custom node packs it requires. Maps each node class_type to its owning node pack using ComfyUI-Manager mappings and the server's installed node definitions, reporting which packs are installed vs missing. READ-ONLY — it installs nothing. Works remotely (HTTP only) — mirrors comfy-cli node deps-in-workflow.

  • action:"install_deps" — MUTATING: this is the ONE action on this tool that INSTALLS anything. Resolve and INSTALL the custom node packs a ComfyUI workflow (workflow) requires, via ComfyUI-Manager: it determines the missing packs, resets the Manager queue, QUEUES THE INSTALLS, starts the worker, and reports what was installed/already-present/unresolved. Installing a pack downloads and runs third-party code (and may pull large files) on the connected ComfyUI host — local OR remote --comfyui-url — and a ComfyUI restart is typically needed before new nodes load. Use action:"extract_deps" first if you only want to SEE what is missing. Mirrors comfy-cli node install-deps.

  • action:"skill_list" — List the bundled ComfyUI model-family + workflow skills shipped with comfyui-mcp (name + description for each). These encode per-family expertise (e.g. krea2-txt2img: native krea2 CLIPLoader, Qwen3-VL encoder, 8-step turbo settings) and the installer-packs system. Call this BEFORE hand-building a workflow from scratch — if a matching skill exists, read its full guidance with action:"skill_read" and prefer a ready installer pack (action:"list") over a generic graph. Claude loads these natively; this action gives the SAME knowledge to any MCP client (e.g. the Codex backend).

  • action:"skill_read" — Return the full body of a bundled skill's SKILL.md by name (name; discover names with action:"skill_list"). Gives you the family's complete expertise on demand — model slots, node graph, recommended settings, and gotchas — so you can build the right workflow instead of guessing. Names are validated (no path traversal) and must match an existing skill directory.

  • action:"generate_skill" — MUTATING: it WRITES to the read-through skill cache on every cache miss, and when install_in is set it ALSO creates that directory and overwrites any SKILL.md in it. Generate a Claude skill (SKILL.md) documenting a ComfyUI custom node pack: its nodes, inputs/outputs, and example workflows. source accepts a ComfyUI Registry ID (resolved via api.comfy.org) or a GitHub repository URL. Uses a read-through cache under ~/.comfyui-mcp/skill-cache (override COMFYUI_SKILL_CACHE_DIR); set refresh:true to bypass it. On cache miss, fetches the repo README and scans its Python NODE_CLASS_MAPPINGS and example workflows over the network (uses GITHUB_TOKEN if set to avoid rate limits), so internet access is required. If a ComfyUI server is reachable it enriches node input/output types from /object_info, but the server is optional. Returns the SKILL.md markdown with structured cache metadata; if install_in is set, also creates that directory (recursively) and writes SKILL.md there, overwriting any existing file.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
nameNoREQUIRED for action:"read_workflow" — the pack name (a directory under packs/, e.g. 'krea2-txt2img-manual'), from action:"list". REQUIRED for action:"skill_read" — the skill name (a directory under plugin/skills/, e.g. 'krea2-txt2img'), from action:"skill_list".
packNoaction:"check_runtime" — a bundled pack name (from action:"list"). Packs are local/free; this confirms it from the actual graph.
graphNoaction:"check_runtime" — a workflow graph to classify (UI or API/prompt format), as an object or a JSON string. Use this for ad-hoc/generated workflows.
actionYesWhich knowledge operation to perform. "list", "list_templates" and "skill_list" take no other parameters; "read_workflow" and "skill_read" require `name`; "check_runtime" takes `pack` OR `graph`; "extract_deps" and "install_deps" require `workflow` (and "install_deps" INSTALLS custom nodes — the only action here that installs, though "generate_skill" also WRITES to disk: its skill cache on every miss, plus `install_in` when set); "generate_skill" requires `source` (optional `install_in`/`refresh`).
sourceNoREQUIRED for action:"generate_skill" — a ComfyUI Registry node ID (e.g. 'comfyui-impact-pack') or a GitHub repository URL.
refreshNoaction:"generate_skill" — bypass the read-through cache and rebuild the SKILL.md, overwriting the cached entry.
workflowNoREQUIRED for action:"extract_deps" and action:"install_deps" — a ComfyUI workflow in API format (JSON string or object).
install_inNoaction:"generate_skill" — optional directory to write the generated SKILL.md into. Created recursively if missing; an existing SKILL.md is overwritten. Omit to only return the markdown without touching disk.
Behavior5/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does so thoroughly. It flags install_deps as 'MUTATING' and the only action that installs, warns that generate_skill overwrites SKILL.md files and writes to a cache, and explains that check_runtime may return 'unknown' which should be treated as possibly paid. It also discloses side effects like ComfyUI restarts, network access, and the distinction between local, API, and third-party paid nodes.

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 very long, but it is well-structured: an initial one-sentence summary followed by a paragraph per action, with clear typographic separation. It is front-loaded with the most important high-level purpose. While some redundancy exists (e.g., repeated emphasis on preferring packs over generic graphs), the length is justified given the tool's nine distinct sub-actions. A slightly tighter edit could earn a 5, but the current structure is far better than a wall of text.

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

Completeness4/5

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

The description is highly complete for a complex tool with nine actions. It covers each action's purpose, parameters, side effects, and, for check_runtime, the exact return shape. However, it does not explicitly describe the return formats for actions like list, list_templates, extract_deps, or install_deps beyond vague phrases like 'reports' or 'lists'. Given that there is no output schema, these omissions leave the agent slightly less informed about the exact data structure to expect.

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

Parameters5/5

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

Schema coverage is 100%, but the description goes beyond the schema by adding contextual meaning to each parameter. For instance, it explains that `name` is REQUIRED for read_workflow and skill_read and reveals how names are validated (no path traversal), and for `graph` it clarifies that it accepts UI or API/prompt workflow JSON and is used to classify runtime. The description also explains the `pack` parameter's purpose in confirming local/free status from the actual graph, which is not present in the schema.

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 clear summary ('Bundled ComfyUI knowledge — installer packs, model-family skills, workflow templates — plus the two workflow-readiness checks') and then enumerates each action with a specific verb and resource (e.g., 'list — List the bundled installer packs', 'read_workflow — Return a bundled pack's ready workflow.json graph'). It distinguishes itself from sibling tools by explicitly recommending pack-based workflows over generic graph building and by referencing panel_* tools as alternatives.

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

Usage Guidelines5/5

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

The description provides extensive when-to-use/when-not-to-use guidance. For example, it says to PREFER applying a matching pack over building a generic graph, to ALWAYS call check_runtime before building/loading non-pack workflows, and for list_templates it notes that the endpoint cannot see core ComfyUI templates and tells the user to check the frontend Templates browser. It explicitly names alternatives like search_custom_nodes and install_custom_node, and distinguishes between read-only and mutating actions.

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

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/artokun/comfyui-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server