celigo/ai1 file

Using Marketplace Templates

Find, install, and reuse pre-built integration blueprints from the Celigo Marketplace -- Templates (unlocked, fully editable, no ongoing updates) and Integration Apps (vendor-maintained, upgrade-protected, receive updates). Covers whole-template install versus copying a single element, how connections are mapped rather than copied, the dependency cascade, and when to start from a blueprint instead of building from scratch. Use when browsing the marketplace, installing a template or Integration App, or copying an existing flow, export, import, or connection into your own integration.

Specification
Skill ID
celigo/ai/using-marketplace-templates
Publisher
celigo
Repository
ai
Installs
0
Files
1
Synced
Sep 23, 2026
How to use it

Open any RiverX project, open the Skills panel in the chat, and search for this identifier. The files are fetched from the source repository at install time.

celigo/ai/using-marketplace-templatesInstalls these files
  • SKILL.md

What this skill tells the agent

<!-- TIER:1 -->

Using Marketplace Templates

The Celigo Marketplace is a catalog of pre-built integration blueprints -- packaged flows, exports, imports, connections, and scripts you can browse, install, or reuse instead of building from scratch. Each listing is one of three kinds: a Template, an Integration App (IA), or an AI Agent. Most decisions come down to Templates vs Integration Apps.

Templates vs Integration Apps

Templates are open, customizable blueprints. Every flow, export, import, and script ships into your account as your own editable resource -- rename, restructure, or rewrite anything. The trade-off: templates receive no ongoing updates. A template is a starting point, not a maintained product; if the source application's API changes, you carry the fix.

Integration Apps (IAs) are vendor-maintained, structure-locked products. Their core flows, mappings, and logic are upgrade-protected so Celigo (or a partner) can ship updates without breaking your customizations. The trade-off: you configure only what the IA exposes (settings, mappings, endpoints) and can't rewrite the core -- in exchange you inherit bug fixes and new features over time.

Choosing wrong has opposite failure modes: pick a template when you needed an IA and you own the integration forever with no upstream fixes; pick an IA when you needed a template and you hit the locked-component ceiling the moment you must customize beyond what it exposes. When unsure, list both and compare.

AI Agents are a third listing type -- browse them in the marketplace to see what's available.

Whole Install vs Single-Element Copy

Two distinct operations, separated by intent:

  • Whole-template install creates a brand-new integration containing fresh copies of every resource in the blueprint. Intent: "set up the whole integration." This runs in the Celigo Marketplace UI installer on the listing's preview page.
  • Single-element copy drops ONE element -- a flow, export, import, connection, or script -- plus everything it depends on, into an integration you already have. Intent: "borrow one piece."

Recognize intent from wording: "install the X template" / "set up X from a template" -> whole install; "copy the Y flow from the X template" / "I just want the customer export" -> single-element copy.

What Gets Copied vs Mapped

When resources land in your account, they fall into two camps:

  • Copied -- flows, exports, imports, scripts, lookup caches, and response mappings become fresh resources you own. There is no link back to the blueprint: editing them doesn't touch the source, and editing the source wouldn't touch them.
  • Mapped -- connections are never copied. The blueprint's connection ids are placeholders; install and copy resolve each one to a real account connection -- reusing a match (same type + endpoint shape) or creating a new one. Connections are shared resources, so copying them would just duplicate credentials pointing at the same endpoint.

A single-element copy pulls the full dependency cascade: copying a flow brings its exports, imports, scripts, and lookup exports -- each dragging in its connection (mapped) and hook scripts -- so you get a runnable element, not a half-wired fragment.

Quick Reference

Templates vs Integration Apps

DimensionTemplatesIntegration Apps (IAs)
After installFully unlocked -- every resource is yours to editStructure-locked -- core flows/mappings/logic are upgrade-protected
Ongoing updatesNone -- a starting point you maintainVendor-maintained -- receives bug fixes and new features
CustomizationRename, restructure, rewrite anythingConfigure only what the IA exposes (settings, mappings, endpoints)
If the source API changesYou fix it yourselfThe vendor ships the update
Best forA fast start you'll own and adaptA supported product you don't need to rewrite
Install pathMarketplace UI installer (preview page)Marketplace UI installer (multi-step wizard)
Single-element copySupported -- pull one element into your integrationInstalled as a whole product

Whole Install vs Single-Element Copy

Whole-template installSingle-element copy
ResultBrand-new integration with fresh copies of everythingOne element (+ its dependencies) added to an existing integration
Runs inCeligo Marketplace UI installerMarketplace UI (into a chosen integration)
ConnectionsMapped during the installerMapped to existing or newly created connections
Use whenYou want the entire integrationYou want to borrow one piece

Start From a Blueprint vs Build From Scratch

SituationDo this
A listing matches your source + destination and you want a fast start you'll ownInstall a Template
You want a supported, auto-updated product and don't need to rewrite core logicInstall an Integration App
You only need one flow or step from an otherwise-unfit blueprintCopy that single element into your integration
No listing matches, or requirements are highly customBuild from scratch

Related Skills

  • getting-started > Build Order -- where installing from a blueprint fits versus building bottom-up
  • managing-integrations -- a whole-template install lands as a new integration you then organize and promote
  • configuring-connections > Quick Reference -- connections are mapped, not copied; verify or create the ones an install needs
  • building-flows > How to Build a Flow -- edit or extend a flow after it lands in your account
  • configuring-exports > Quick Reference -- exports pulled in by the dependency cascade
  • configuring-imports > Quick Reference -- imports pulled in by the dependency cascade
  • writing-scripts > Quick Reference -- hook scripts copied alongside flows and steps

<!-- TIER:2 -->

How to Use a Marketplace Template

1. Check what already exists

Before installing anything, search the account so you don't duplicate an integration or connection you already have.

celigo account search "<keyword>"

2. Browse the marketplace

List catalog entries and note whether each is a Template or an Integration App.

celigo marketplace list
celigo marketplace list --type template

UI (primary): the Marketplace UI is the primary place to browse and install -- open the listing's preview page there.

3. Decide: Template, Integration App, or build from scratch

Use the Quick Reference tables. Key questions:

  • Do you need ongoing vendor updates (-> Integration App) or full control (-> Template)?
  • Do you need the whole integration (-> install) or one piece (-> copy)?
  • Does anything even match (-> otherwise build from scratch)?

4. Preview before you install

Inspect the blueprint's contents and the connections it expects before committing.

celigo templates preview <id> --summary
celigo templates preview <id> --model Connection

5. Install a whole template or Integration App

Whole-template and IA installs run in the Celigo Marketplace UI installer on the listing's preview page. The installer walks the multi-step wizard: mapping or creating connections, accepting the license, selecting a plan, and configuration.

Use this skill in a project

Open any RiverX project, search the Skills panel for celigo/ai/using-marketplace-templates, and install it in one click.

Use this skill