CNAPS.ai MCP Server

Cancel a currently running flow. Sends a stop signal — the flow will stop after completing the current processing step. Use get_flow(view="status") to confirm it has stopped. A node whose wait.phase is "queued" is waiting its turn, not stuck: cancelling and running again only puts it at the back of the line.

Publish one of your flows to the cnaps.ai community. Creates a community post with a snapshot of the flow. Others can then discover and fork your flow. Requires a source_flow_id (from list_flows) and a title. A fork copies an input node's value only when that node's include_in_fork is on (get_flow shows it per input node): text inputs are on by default, image, video, audio and file inputs are off, so forkers get those inputs empty. To let forkers run your example media straight away, set include_in_fork=true on those input nodes with update_flow before publishing — the post keeps the snapshot taken now, so a later change needs a new post.

Create a flow. Provide the models in order — input/output nodes and connections are generated automatically by matching output→input port types, and the original input is shared (fan-out) when several models need it. Set run=true to start it immediately in the same call.

Move a flow to trash. It can be restored from the trash within 30 days; after that it is permanently deleted.

Analyze a failed flow run and suggest fixes. Provide the flow_id of a failed flow. Returns root cause analysis, the specific failing node, a concrete fix suggestion (e.g. insert a Resize node, change a parameter), and confidence level. Use this whenever get_flow(view="status") shows a failed node.

Duplicate an existing flow. Creates a deep copy with fresh state (no results). Use this to copy a flow and then modify it with update_flow, instead of recreating from scratch.

Change the STRUCTURE of an existing flow in place: add or remove nodes, swap the model on a node, and connect or disconnect ports. This is the tool for "add an upscaler to this flow", "use a different model here", "rewire this" — do NOT create a new flow to modify one that already exists (update_flow only changes name, tags and node parameters). All operations in one call are applied together: either every one lands or none does. Read the flow with get_flow first to get node IDs, and get_model for port layouts before wiring.

Find models that can connect to a given model in a flow. Use 'downstream' to find models whose inputs match this model's outputs (what can come AFTER). Use 'upstream' to find models whose outputs match this model's inputs (what can come BEFORE). Returns compatible models sorted by number of matching ports. Use this BEFORE creating a flow to ensure models can be wired together.

Copy a home-page card into the user's workspace as a flow, ready to run. Returns flow_id, the inputs to fill (each with the node_id run_flow keys its inputs by) and the settings the card lets you change. Then upload_file → run_flow(flow_id, inputs) → get_flow(view="status", wait_seconds=20). The flow appears in the user's flow list, so it can also be opened and edited in Studio. Get card_id from search_cards.

Fork (copy) a community flow into your workspace. After forking, the flow is yours — you can run it with run_flow, modify it, or use it as a starting point. Get post_id from search_community results.

Fork (copy) a flow template into your workspace. After forking, you can run it with run_flow.

Check the status of a batch run. Returns progress and output file URLs when completed.

Get detailed information about a community post, including title, content, tags, input/output types, and engagement stats. Use this to preview a post before forking it.

Read a flow. Pick the view that answers the question: 'detail' (default) for the raw nodes, connections and parameters — use this to discover node IDs; 'summary' for a plain-language description of what the flow does; 'status' for execution state and output file URLs — a running node's wait.phase tells queued (waiting for a GPU, with jobs ahead) from loading_model, starting, generating and finishing; 'validation' for pre-run problems (trashed, running, missing inputs, disconnected nodes). To follow a run, call view='status' with wait_seconds=20: the call returns as soon as the run ends, or after 20 seconds with the run still going — then call it again. No need to sleep between calls.

Get your user profile information (ID, email, name).

Get detailed information about a specific AI model, including its inputs, outputs, parameters, and plan requirements.

Get the configurable parameters schema for a specific AI model. Use this to understand what settings can be adjusted when creating a flow with this model.

Get your notifications (community activity, workspace, run results, billing and system notices), along with the unread count. Returns cursor-paginated results — use next_cursor from the response for subsequent pages.

Get GPU usage for your workspace. Shows usage percentage, plan limits, and reset schedule. Timestamps are unix milliseconds. The credit window is a rolling one that starts when credits are spent, not a fixed clock schedule, so next_reset_at and last_reset_at are absent whenever no window is running — before the first spend and again after each window expires. In that case reset_hint explains the state; report it rather than inventing a reset time.

Get information about your current workspace, including subscription plan, member count, and seats.

List AI flows in your workspace. Returns flow names, statuses, and metadata with pagination.

List available LLM providers and whether your workspace has configured API keys for them. Configured providers enable external model nodes in flows.

List available AI models on cnaps.ai with optional filters. Returns model names, types, input/output port types, and accessibility. Use filters to narrow results instead of browsing all models.

List curated flow templates on cnaps.ai. Templates are pre-built, tested flows for common tasks. Fork a template with fork_template to use it.

Mark notifications as read. Pass notification_id for one; omit it to mark them all.

Analyze a flow for performance and cost optimization opportunities. Returns rule-based suggestions such as moving upscale nodes to the end of the flow, avoiding resolution overflow, removing redundant processing, and choosing better-performing models. Each suggestion carries a structured patch (move_node, insert_node, replace_model) describing the change. Apply them with edit_flow on the same flow — replace_model maps to its replace_model op, insert_node to add_node plus the connect/disconnect that splice it in. move_node is layout only and needs no edit. Applying a suggestion never requires creating a new flow. update_flow changes node parameters only. Use this before running a flow or while iterating on its design. Set include_llm_analysis=true to also ask Haiku for complex-pattern refinements.

Check whether a flow can be wired together, and see what create_flow would produce — without creating anything. Returns compatibility, per-model wiring, required inputs and final outputs, plus the node structure and connections. Takes the same nodes and connections arguments as create_flow, so a hand-wired graph can be checked before it is created: a port-type mismatch comes back with the model's real port layout instead of a failed create.

Report a tool failure or confusion to the cnaps.ai team. Use this when you encounter persistent errors, unclear documentation, or missing features. Reports are stored and analyzed to improve the platform.

Restore a flow from trash back to active state. Flows stay in the trash for 30 days, then are permanently deleted. Use list_flows with state='trashed' to find trashed flows.

Run a flow in batch mode with multiple input file sets. Each input node receives an array of file URLs (uploaded via upload_file). Returns a batch_run_id to track progress. Batch runs need the Starter plan or above, and the plan caps the input sets per batch. Every node runs for every input set, so result locks (update_flow locked) do not apply here.

Execute a flow. It runs asynchronously — call get_flow(view="status", wait_seconds=20), which answers when the run ends, until it completes. For flows with input nodes, provide file URLs (from upload_file) via the inputs parameter. This runs the flow ONCE; use run_batch for multiple input sets. On a re-run, nodes whose inputs and parameters are unchanged keep their results, except ones that come out different every time (LLM and API models, random seeds), which run again — unless locked: lock the finished results to keep with update_flow (locked=true) first, so only the rest are regenerated.

Search the ready-made cards on the cnaps.ai home page — flows the cnaps.ai team built, tested and published for common tasks (remove a background, restore a photo, make an ad video…). Check here FIRST when the user describes a task: a card that fits is better than building a flow from models. Matches words in any language against every card's title and description, rarer words and title words counting more. cards holds the closest few matches in full; other_cards lists more by title only, closest first, and when the matches cover only some of your words it lists every other card too — read their titles. When nothing matches, cards is every card by title (matched=false) so you can pick one by meaning. Pass a card id as query to get that card's details. Run a card with fork_card.

Search community-shared AI flows on cnaps.ai. Find flows by keyword, input/output modality, or tags — or pass none of them to browse in sort order. Use this to discover existing flows before creating new ones. Returns post IDs that can be forked with fork_community_flow.

RECOMMENDED FIRST STEP for any image/video/text processing request. Ask it which model or models to use — it answers for a single step and a multi-step chain alike, since a one-model flow is just a flow. Understands natural language (English, Korean, and more) and returns models in order, with parameter recommendations and wiring. Use this BEFORE list_models — it handles parameter inference (e.g. '4K' → scale_factor=4) and model selection automatically. Pass the result straight to create_flow.

Change an existing flow: rename it, replace its tags, and/or update node parameters. Provide any combination — one call can do all three. Node parameters are merged with existing values, so specify only what changes; tags replace the existing set. Cannot update a flow that is currently running. This tool does NOT change the graph: to add or remove a node, swap a node's model, or rewire ports, use edit_flow — never create a new flow to restructure an existing one.

Get a file into cnaps.ai so a flow can use it. Handles images, video, audio and text (png, jpg, webp, avif, RAW / mp4, mov, webm, mpeg, avi, flv, wmv, 3gp / wav, mp3, m4a, aac, ogg, flac / txt). TIFF is stored as PNG either way; HEIC (iPhone photos) only through the upload link, which stores it as JPG. Two ways in, chosen by what you pass: (1) The user gave a public HTTP/HTTPS URL → pass file_url and it is registered directly. (2) The files are on the user's machine → pass nothing, and you get back an upload link to show them; then call again with the returned token to wait for the upload and get the URLs. One link takes multiple files — up to 20 files per link, dropped together or a few at a time — so make ONE link for several files, not one per file. A link is used up once the user presses Upload. You CANNOT send bytes from the chat through MCP — even if you can see the image or video, use the link flow. Returns URLs usable in create_flow input_files or run_flow inputs.