Articles in this section

Celigo Ora use cases and prompts

Kathyana Queeman
Updated

Below are some common use cases and prompts for Celigo Ora. Ora can do much more, but these examples are a starting point.

Ora is currently in BETA mode and can make mistakes. Always review changes before approving them.

Navigate the Celigo platform with Ora

Take me to Connections.

Open the ‘<flowName>’ flow (_flowId) and take me directly to the ‘Import Acumatica employees’ step settings.

Navigate to the integration ‘<integrationName>’ (_integrationId), then open its audit log for the last 7 days.

Account architecture and analysis

Ora can help you manage your account by surfacing and modifying account-level settings and governance items you have permission to manage. It can also analyze your account's health and run simulations for account changes. 

Account Architect

What are the top 10 busiest flows in the last 7 days?

If I delete the connection ‘<connectionName>’ (_connectionId), what breaks? Simulate the impact and list affected resources.

Run an account lint: find orphaned resources + duplicates, then propose a cleanup plan.

Update account profile and preferences

Update my account settings as follows: enable SSO enforcement (if available), set the session timeout to 60, and set data retention to 30 days. Then update my preferences: set the timezone to America/Los_Angeles, date format to DD/MM/YYYY, and enable dark mode. After making the changes, show me a summary of what will change so I can approve it in the UI. I am an account owner.

Monitor subscription and entitlement usage

Show me a summary of my account subscription plan, including entitlements/limits and current usage (what I’m using vs. what I’m allowed). Include any overages or “near limit” items, and break it down by major categories (for example: connections, flows, runs, errors/data retention—whatever applies to my plan).

AI agents

Show me all AI Agent imports in my account.

Create an AI Agent that classifies incoming tickets and outputs JSON with severity, category, and routing team.

Update the AI Agent (_aiAgentId) to use a cheaper model for low-severity tickets but keep high-severity on a stronger model.

APIs

Create a GET endpoint /health that returns {ok:true}.

Build a POST /orders API that validates the schema, writes to a datastore, and triggers a flow.

Add GET /quarantine?from=&to=&reason= to return dead-letter records with pagination and filters.

Audit logs

Summarize my account audit logs for the last 60 days. Group the results by resource type (flows, connections, integrations, users, scripts, etc.) and within each group sort by most recent first. For each group, include: (1) total number of changes, (2) a breakdown by action (create/update/delete/restore), (3) top 5 most-changed resources, and (4) the top users who made changes (by count). Also call out any security-related changes (SSO/MFA/permissions) separately.

Connections

Create a new Slack connection named ‘<connectionName>’. Use OAuth, then confirm the connection is online.

List all connections that are currently offline. For each one, show the connection name, application type, and which flows/imports/exports depend on it.

Clone my ‘<connectionName>’ (_connectionId) into a new connection named ‘<newConnectionName>’. Re-authenticate it for the sandbox org, then update every flow in the ‘<integrationName>’ integration to use the new sandbox connection instead of production—without changing any other mappings, schedules, or step settings. Provide a summary of every step updated.

Rotate the API token/credentials used by my ‘<connectionName>’ connection. Before applying changes, show me everything that uses that connection (flows, exports, imports, APIs, MCP servers). Then stage updates so only the ‘<flowName>’ flow uses the new credentials first; after validation, apply the same credential update everywhere else. Include an audit-style summary of what changed and what was left untouched.

Dashboard

Show any flows currently running.

Summarize completed runs for the last 7 days by flow: success rate, error count, average duration.

Compare yesterday vs baseline and flag anomalies in run volume or error rate.

EDI profiles

Generate an EDI profile from the provided raw X12 ISA/GS snippet.

Create partner profiles for 3 trading partners and standardize ISA/GS settings across them.

Analyze why 997 acknowledgements aren’t being generated and what profile fields likely need adjustment.

Error management

Assign all errors tagged ‘auth’ to user X and apply a ‘needs-credentials’ tag.

Retry all errors from last 24 hours for _flowId after updating retry data to fix missing fields.

Analyze errors for _integrationId over the last 30 days as follows. Do not make configuration changes yet.

  • Likely root cause category: authentication/permissions, data validation/mapping, missing reference/lookup, rate limit/throttling, network/timeout, duplicate/conflict, schema change, other.

  • Evidence from the error payload/response (key fields, response codes, destination messages).

  • Whether it’s likely systemic (config-wide) or data-specific (only some records).

  1. Summarize error volume and trends:

    • Total errors, unique error messages, and daily trend.

    • Break down by flow, then by step (export/import) within each flow.

    • Identify the top 10 error signatures (normalize by error code/message so minor variations group together).

  2. Cluster and explain root causes. For each top error signature, provide:

  3. Operational impact and prioritization:

    • Flag any errors affecting: revenue/order flows, customer syncs, or high-volume steps.

    • Identify which errors are retriable vs which require data correction.

    • Recommend a prioritized fix list: P0/P1/P2 with rationale.

  4. Actionable remediation plan. For the top 3 root causes, propose:

    • The smallest configuration change that would reduce error volume.

    • Any mapping/filter/hook adjustments needed (show exact fields/steps impacted).

    • A safe rollout plan (e.g., enable debug logging for 30 minutes, test with a small sample, then apply).

  5. Error handling improvements:

    • Recommend improvements to prevent recurrence: input validation, quarantine routing, better response mappings, idempotency keys, or rate-limit backoff.

    • Suggest tags to apply for ongoing triage (e.g.,auth, mapping, rate-limit, missing-ref).

  6. Output format. Return results as:

    • A short executive summary

    • A table grouped by flow/step with counts

    • A list of top error signatures with recommended next actions

Exports

Below are some example export prompts:

Shopify

Create a Shopify export named ‘<exportNameShopify>’.

Requirements:

  • Source: Shopify Admin API (use my 'Shopify' connection).

  • Data scope: orders updated since the last successful run (use a saved watermark; if none exists, default to last 24 hours).

  • Filters:

    • status=any

    • exclude test orders

    • only include orders with at least 1 line item

  • Fields to output (flattened JSON):

    • order_id, order_name, updated_at, created_at, currency, total_price, financial_status, fulfillment_status

    • customer: customer_id, email

    • shipping: country, province, zip

    • line items array with: sku, quantity, price, product_id, variant_id

  • Handle pagination and rate limiting (backoff/retry).

  • Add a transform that normalizes timestamps to ISO-8601 UTC and ensures sku is never null (set to an empty string if missing).

Stage the export as a draft and show the request configuration + sample output for 2 orders.

NetSuite

Create a NetSuite export named ‘<exportNameNetSuite>’

Requirements:

  • Source: NetSuite (use my NetSuite connection <_connectionId>.

  • Use a Saved Search (or SuiteQL if more appropriate) to pull customers modified since the last successful run.

  • Include joins/related data:

    • customer core fields: internalId, entityId, companyName, email, phone, isInactive, dateLastModified

    • default billing and shipping addresses (street/city/state/zip/country)

    • terms and subsidiary (IDs + names)

  • Filters:

    • exclude inactive customers

    • exclude customers without email

  • Output format: JSON with a stable schema.

  • Performance:

    • Implement paging so it can handle large result sets safely

    • avoid pulling unnecessary columns

  • Add a preSavePage script/transform that:

    • trims/normalizes email to lowercase

    • validates required fields and tags invalid records withvalidation_errors[]

Stage the export and show the exact NetSuite query/search definition and a sample record.

Jira

Create a Jira export named‘ <exportName>'

Requirements:

  • Source: Jira Cloud (use my Jira connection).

  • Pull issues updated since the last successful run using JQL based on updated >=.

  • Include projects: PROJ, OPS, and SUP.

  • Include issue types: Bug, Task, Story.

  • Fields to output:

    • issueKey, issueId, projectKey, issueType, status, priority, assignee.email, reporter.email

    • summary, description (plain text if possible), labels[], components[]

    • created, updated, resolutionDate

  • Add logic to capture:

    • whether the status changed since last run (use changelog if available; otherwise infer)

    • a normalized status_category field (To Do / In Progress / Done)

  • Handle pagination and API throttling.

Stage the export and show the JQL, the field list used, and sample output for 3 issues.”

File definitions

Create a CSV file definition for columns: id, email, created_at.

Create an X12 850 file definition and map it to our purchase order schema.

Update the file definition to handle optional segments and enforce validation rules.

Flows

Run <_flowId> once.

Add a router: invalid records to quarantine, valid records proceed; stage as draft and summarize changes.

Clone <_flowId> into 3 instances (per region), parameterize connections via lookup cache, and schedule each differently.

Guardrails

List all guardrails currently configured.

Create a guardrail that detects PII and blocks payloads containing SSNs or credit card numbers.

Tune the guardrail thresholds and add an exception policy for internal test environments.

iClients

Show me all OAuth iClients.

Create an iClient for Salesforce OAuth with correct redirect URIs and attach it to the Salesforce connection.

Rotate the client secret and update all dependent connections safely.

Integrations and revisions

Show flow analytics for ‘<flowName>’: error trends, success rate, and slowest flows.

Create a revision snapshot for ‘<flowName>’ named ‘pre-dbt-change’. 

List revisions and revert ‘<integrationName>’ integration to the snapshot from February 1, 2026.

Create a revision snapshot, apply changes, then create a second snapshot so I can roll back.

Pull changes from the related integration in another environment, excluding credentials and schedules.

Imports

Add a field mapping: map email into the destination email field.

Auto-map <_importId>, then add custom Handlebars for address normalization and a preMap hook.

Convert <_importId> to upsert behavior and add response mapping to write back destination IDs.

Field mappings

Update the following four NetSuite import configurations. Do not change any other flows/steps beyond what’s listed. Stage all changes for review and then give me a summary of exactly what changed per import. Finally, after staging the changes, list each import with: what fields/mappings changed; what filters/hooks were added; any assumptions you made (if any); and any required follow-ups.

  1. Import: “<importName>”

    • Set the operation to Upsert using External ID = custentity_external_id.

    • Add/update mappings:

      • entityId ← {{record.customer_number}}

      • email ← {{lowercase record.email}}

      • phone ← {{record.phone}}

    • Add an input filter to skip records with missing email.

  2. Import: “<importName>”

    • Add a preMap hook that:

      • ensures tranDate is ISO-8601 (convert if needed)

      • sets memo to "Created by integrator.io" when blank

    • Add a mapping for externalId ← {{record.order_id}}.

    • Enable “Ignore duplicates” behavior (if supported), so replays don’t create extra orders.

  3. Import: “<importName>”

    • Add a mapping for createdFrom (Sales Order internalId) ← {{lookup "so_internal_id" record.order_id}}.

    • Add an input filter to only allow records where shipStatus = shipped.

    • Update error handling so records missing createdFrom are routed to a quarantine/error queue (do not hard-fail the entire run).

  4. Import: “<importName>”

    • customer ← {{record.ns_customer_internal_id}}

    • payment ← {{record.amount}}

    • tranDate ← {{record.payment_date}}

    • Add response mapping to capture internalId and write it back as record.ns_payment_internal_id.

Lookup cache

Create a lookup cache named ‘env’ with keys region, slack_channel.

Populate a cache with 500 SKU mappings from this table and use it in 3 flows.

Purge stale entries older than 90 days and repopulate from the source-of-truth export.

MCP servers

List my MCP servers.

Create an MCP server that exposes 2 APIs and 1 Tool, with token auth and per-tool enable/disable.

Preview the MCP server, fix validation errors, and publish the corrected config.

Create an MCP Server named “serverName” that exposes a small, safe toolkit for NetSuite operations. Requirements:

  1. Auth and access:

    • Use an API token named “<apiTokenName” (create it if it doesn’t exist).

    • Restrict the token to only the resources used by <_mcpServerId> (do not use full-access).

  2. Add these tools/APIs to the MCP server:

    • Tool: “<toolName>”

      • Input: externalId

      • Action: query NetSuite and return a normalized customer object.

    • Tool: “<toolName>”

      • Input: customer payload

      • Action: upsert customer in NetSuite using externalId; return internalId and status.

    • Tool: “<toolName>”

      • Input: orderExternalId, customerExternalId, lineItems[]

      • Action: create SO only if orderExternalId hasn’t been processed; return SO internalId.

    • API: “<apiName>” (backed by the “<toolName>” tool).

      Query param: externalId

    • API: “<apiName>” (backed by “<toolName>” tool)

  3. Safety controls

    • Add a guardrail-like validation step before any write:

      • Reject payloads missing required fields

      • Reject line items with quantity &amp;lt;= 0

      • Reject orders over $50,000 unless approved=true

    • Ensure all write tools return a standardized result: { "ok": true|false, "action": "string", "ids": {"customerId":"","orderId":""}, "errors": [{"code":"","message":"","details":{}}] }

  4. Preview and validation

    • Run an MCP preview/validation.

    • Fix any validation errors.

    • Leave the MCP server enabled only after it previews cleanly.

  5. Output

    When done, provide:

    • MCP server name + id

    • list of added items (tools/APIs)

    • which token it uses and what it is scoped to

    • a short example of calling POST /netsuite/order with sample JSON

Mappings and transformations

The most effective prompts are:

  1. Scoped (which flow + which step)

  2. Structured (a small table/list of “from → to” rules)

  3. Concrete (sample input + expected output, plus any handlebars/helpers)

Below are some prompt templates:

Example 1 – “Mapping patch” format (recommended)

Context:

  • Flow: [flow name]

  • Step: [import step name] or [export step name]

  • Mapping area: [Field mappings] (and specify: body vs line-level / subrecord if relevant)

Change requests (add/update/remove):

In flow [X], step [Y import], update field mappings:

  1. Set destination A from source $.path1

  2. Set destination B to handlebars: {{expression}}

  3. Remove destination C mapping.

Rules/constraints:

If [condition] then [value] else [value].

Required fields: [...]

Data type expectations: [...]

Example 2 – Handlebars/expression changes

If you want Handlebars/expression changes, include the helper + intent. If you need logic (if/else, comparisons, string ops), explicitly say:

  • Where the expression goes (which destination field)

  • What it should do (plain English)

  • Any helper preference (e.g., compare, if/else, etc.)

For example: "Update the mapping for destination field status. If $.isActive is true, map "ACTIVE" else map "INACTIVE" using a handlebars if/else expression."

Example 3 – Complex JSON (nested/arrays)

If the mapping is complex JSON (nested/arrays), describe the shape + what to extract.

For arrays/subrecords, add:

  • The array path (e.g., $.lines[*])

  • The key you want to match on (e.g., SKU)

  • Whether you want a single value or a mapped array

If you’re using Celigo AI to generate handlebars for complex structures, include a small sample payload and the exact target shape you want.

On-premise agents

Rotate the agent token and show which connections depend on that agent.

Audit agent activity and recent changes across the last 7 days.

Scripts

Explain what <_scriptId> does.

Update <_scriptId> hook to handle null-safe parsing and add unit-test-like sample inputs/outputs.

Find every script referencing oldFieldName and update them to newFieldName.

Stacks

List my stacks.

Clone the stack and point the cloned integration to the new stack.

Show all flows calling <_stackId> and what would break if I disable it.

Tools

Create a Tool that converts a date string to ISO-8601.

Create a Tool ‘<toolName>’ that outputs {code, message, details, source} and reuse it across 5 flows.

Refactor 3 flows to replace inline transforms with a shared Tool, without changing output.

Trading partners

List trading partner connectors.

Create a connector template for onboarding new X12 partners with required fields and defaults.

Update the connector to include 855 + 856 document types and validate envelope settings.

User management

List all users and their roles.

Disable access for users inactive for 90+ days and summarize who was changed.

Audit permission changes over the last 60 days and flag any Admin/Owner changes.