Celigo CLI + LLM: Prompt Your Integrations in Plain Human Language

In 2026, most integration teams have tried an AI assistant for writing code. Far fewer have realized that the same assistant can now operate their iPaaS. With the release of the official Celigo CLI (@celigo/celigo-cli), everything in integrator.io — flows, connections, exports, imports, jobs, users — became scriptable from the command line. And anything scriptable from the command line can be driven by an LLM such as Claude.

That combination unlocks a new way of working: instead of clicking through the integrator.io UI, you describe what you want in plain language — “why is this job failing?”, “document all my integrations”, “build a Shopify → NetSuite flow” — and the AI finds and runs the right commands. In this post, we look at why the two compose so well, twelve concrete ideas you can build, and how to hook the CLI up to Claude today.

Why the Celigo CLI and LLMs compose so well

The CLI is unusually LLM-friendly, and much of that appears to be by design:

• Everything is JSON. Every resource — flows, exports, imports, connections, scripts — round-trips as JSON via get/create/set, with --jq filtering built in. LLMs are very good at reading and writing JSON.
• AI skills ship with the CLI. Installing it symlinks skills into ~/.claude/skills/, each with a workflow guide and OpenAPI-derived schemas — so the AI writes configuration that actually validates against integrator.io.
• celigo account snapshot builds a local index of your whole account (search plus dependency graph) that an LLM can query without hammering the API.
• celigo account lint produces machine-readable findings an LLM can turn directly into fixes.
• Profiles. --profile prod / --profile sandbox make cross-account diffing and promotion scriptable — and safe to delegate.

Twelve ideas, from safe to ambitious

1. Chat with your account (“Celigo Q&A”)

Load the snapshot index into the AI’s context and ask questions like “Which flows write to NetSuite item records?”, “What breaks if I change this connection?” or “Where is the customer email address mapped, across all flows?”. Zero write access needed — the perfect first project.

2. Auto-documentation of your integrations

Nobody documents their integrations — an LLM will. Dump every flow as JSON and let the AI generate a README per integration: what it does, source → destination, schedule, mappings in plain English, scripts and owners. Re-run it on a schedule and the documentation never goes stale.

celigo account snapshot
# or per-resource dumps:
celigo flows list --jq -r '.[]._id' | while read id; do
  celigo flows get "$id" > "snapshot/flows/$id.json"
done

3. Error triage & self-healing agent

A scheduled agent watches celigo jobs list --status failed, classifies each failure (expired credentials, mapping error, rate limit, bad data), suggests the fix and — for known-safe categories — retries automatically. Unknown categories become a Slack or email summary in human language instead of raw error dumps.

4. Ops digest on a schedule

Combine jobs list, audit list and notifications list into a daily or weekly narrative: “Three flows degraded since Monday, all sharing the Shopify connection — token likely expiring.” Delivered to Slack or email, readable by non-developers.

5. Config drift & change review bot (GitOps)

Commit nightly snapshots to git. On each diff, the LLM writes a human-readable changelog — “Flow X: schedule changed from hourly to every 15 minutes” — and uses celigo audit list to attribute who changed it. Run it in CI as a PR comment bot for your integration platform.

6. Lint-and-fix loop

Feed celigo account lint --format json to the AI: it prioritizes findings, explains their impact in business terms and drafts the celigo ... set commands to remediate. A human approves, a script executes. The same loop works for naming conventions and tag hygiene.

7. Sandbox → production promotion assistant

The LLM diffs the same flow across --profile sandbox and --profile prod, flags environment-specific values that must not be promoted (connection IDs, URIs) and generates an ordered promotion plan. Doing this by hand is one of the most error-prone iPaaS tasks there is.

8. Natural-language flow builder

Describe an integration in plain English — “sync Shopify orders to NetSuite daily, skip refunds” — and the AI uses the shipped skills to generate connection, export, import and flow JSON, then applies it with celigo ... create. The safer variant: the AI writes JSON to a proposed/ folder, you review the diff, a script applies it. Infrastructure-as-code with an AI author.

9. Mapping & script copilot

Give the AI a sample source record and a destination schema; it drafts Mapper 2.0 mappings, Handlebars expressions or hook scripts (preMap, postSubmit…). It also works in reverse: paste an existing script and ask for an explanation or a code review.

10. EDI onboarding accelerator

Trading-partner onboarding usually means reading a PDF spec and hand-building profiles. Instead: the LLM reads the partner’s X12/EDIFACT spec, generates EDI profiles and file definitions via celigo edi-profiles and celigo file-definitions, and drafts test transactions.

11. Security & access review

The AI reviews users list, connections list and iclients list for over-broad access, stale invites, weak auth methods and MFA gaps — producing a quarterly access-review report that would otherwise take a day to compile.

12. Flip it around: Celigo as an MCP server

integrator.io supports MCP servers natively (celigo mcp-servers). Instead of the LLM driving the CLI, build Tools in Celigo and expose them via MCP so Claude — or any MCP client — can call your integrations: “look up order status for customer X” hits a governed Celigo tool with guardrails instead of a raw API.

How do you connect the CLI to Claude?

The goal: you type “disable all flows matching prod-v1” and the AI finds and runs the right celigo commands. There are four ways to get there, easiest first.

Option A — Claude Code (recommended, works out of the box)

The CLI ships this integration natively. Installing it globally symlinks Celigo skills into ~/.claude/skills/ — each containing a workflow guide plus the official API schemas, so Claude knows the correct commands and writes JSON that validates.

# 1. Install CLI (this also installs the skills for Claude Code)
npm install -g @celigo/celigo-cli

# 2. Verify skills landed
ls ~/.claude/skills/ | grep celigo

# 3. Authenticate
export CELIGO_API_TOKEN="<your token>"

# 4. Start Claude Code and just talk
claude
> "List all disabled flows and tell me which integration they belong to"
> "Why is job 68a... failing?"

Because Claude Code has shell access, it does not just suggest commands — it runs celigo flows list --format json, reads the output and iterates. Skills trigger automatically based on your question: “debug this stuck job” loads troubleshooting-flows. The same mechanism works for Cursor and Windsurf.

Option B — Claude Cowork

Claude in Cowork has a sandboxed Linux shell, so the same pattern works per session: install the CLI with npm, provide the API token, then prompt in chat — “check my failed jobs and summarize.” Combine it with Cowork’s scheduled tasks for the ops-digest idea above.

Option C — MCP server (for Claude Desktop or claude.ai without shell access)

Two flavors. Celigo-native: expose Tools and APIs as MCP endpoints (celigo mcp-servers create) and add that endpoint as a custom connector in Claude — best for business users asking things like “what’s the status of order 1234?”. Wrap the CLI yourself: a small MCP server (roughly 50 lines of Node with the MCP SDK) exposing one tool that shells out to the binary and returns the JSON. Restrict the allowed subcommands to keep it safe.

Option D — Your own agent (Claude API / Agent SDK)

For a fully custom application: give Claude a bash tool in a tool-use loop and put the CLI reference in the system prompt. The docs are LLM-ready — every page is available as markdown by appending .md, with https://developer.celigo.com/llms.txt as the index. This is how you would productize the flow builder or the triage agent.

Where to start

A good first experiment: run celigo account snapshot, open Claude Code (the skills are already installed with the CLI) and start asking questions about your own account. Read-only, ten minutes of setup, and it immediately shows what this combination can do.