---
name: gentic-support
description: "Give your AI agent your customer support tickets. Sync Gorgias tickets into your Brain with incremental polling, then search them semantically with optional SQL filters — all through the Model Context Protocol. Pay per synced ticket; search is free."
license: MIT
metadata:
  author: gentic
  version: "1.0.0"
---

# Gentic Support

Connect any AI agent to your customer support. Sync your Gorgias tickets — full message threads and all — into your organization's Brain, then search them in natural language: 'what are customers complaining about?', 'what themes are we seeing this week?', 'find tickets about shipping delays'. Incremental polling keeps the picture current without re-reading the whole backlog.

## When to apply

- User wants to know what customers are complaining about, or the top themes in recent tickets.
- User wants to find support tickets about a specific issue, product, or topic.
- User wants to sync their Gorgias tickets into their Brain for search and analysis.
- User wants to poll for new/updated tickets on a schedule without re-reading the whole backlog.
- User wants to count or aggregate tickets — volume per day, breakdown by status or channel.
- User wants to feed recent support conversations into a digest, triage flow, or product feedback loop.

## Tools

| Tool | Description | Cost |
|------|-------------|------|
| `gorgias_sync_status` | Check the status of an async gorgias_sync_tickets chunk by its `job_id`. Returns `{ status: 'processing' \| 'completed' \| 'failed' }`, and when completed the chunk result: `{ count, next_cursor, has_more, latest_updated_datetime, timed_out }`. Use this when you didn't pass a `webhook_url` to gorgias_sync_tickets: poll until status is 'completed', then save `next_cursor` and call gorgias_sync_tickets again with it until `has_more` is false. Free. | Free |
| `gorgias_sync_tickets` | Sync support tickets from Gorgias into this organization's Brain (the per-org `support_tickets` table) — ASYNC, one chunk per call. Uses the org's connected Gorgias integration (dashboard → Integrations); no API key is passed here. Returns immediately with `{ job_id, status: 'processing' }`; the actual work (pull a page of tickets, fetch messages, embed, upsert deduped on the Gorgias ticket id) runs off-box and the chunk result — INCLUDING `next_cursor`, `has_more`, `latest_updated_datetime`, `count` — is delivered when done. Provide `webhook_url` to have that result POSTed to you (the recommended flow for n8n: save `next_cursor` from the webhook and call again with it until `has_more` is false); without a `webhook_url`, poll `gorgias_sync_status` with the returned `job_id`. Two modes via `mode`: 'incremental' (default) pulls NEWEST-FIRST — right for 'the most recent N tickets' (`limit: N`, no `updated_since`), for a date-bounded backfill (`updated_since: '2025-01-01T00:00:00Z'`, then page with `next_cursor`), and for ongoing polling (pass back `updated_since`); 'backfill' walks OLDEST-FIRST through full history via `cursor`. Billed 1¢ per ticket actually synced (charged when the chunk completes, not at dispatch). | 1¢ / result |
| `search_support_tickets` | Search this organization's support tickets by natural language — the right tool for 'what are customers complaining about regarding <product>?', 'what themes are we seeing this week?', 'find tickets about shipping delays'. Searches the `support_tickets` table (populated by gorgias_sync_tickets) semantically over each ticket's conversation text, returning full ticket rows ranked by relevance. Supports an optional SQL `filters` clause over the structured columns to narrow results — e.g. status, channel, customer_email, ticket_created_at/ticket_updated_at (TIMESTAMP), tags (JSON). Example: search_support_tickets(query='damaged on arrival', filters="status = 'open' AND ticket_created_at > '2026-06-01'"). For pure counts/aggregations (group by status, ticket volume per day), use query_data over the support_tickets table instead. | Free |

## Workflow

### 1. Connect Gorgias once, then sync without credentials

The Support server sources the Gorgias connection (domain, email, API key) from the org's connected integration (Gentic dashboard → Integrations → Gorgias). You never pass credentials to the tools — connect once in the dashboard and the server reads the encrypted connection automatically. If `gorgias_sync_tickets` reports no connection, point the user to Integrations → Gorgias.

### 2. Sync tickets into the Brain with `gorgias_sync_tickets`

`gorgias_sync_tickets` is **1¢ per synced ticket**. It pulls tickets updated-ascending with cursor pagination, fetches each ticket's full message thread, and upserts into the per-org `support_tickets` table deduped on the Gorgias ticket id — so a ticket update refreshes the same row rather than creating a duplicate. `limit` (1–100, default 25) caps how many tickets this call gathers; keep batches modest for interactive use since each ticket also incurs a messages fetch and an embedding. Returns `{ tickets, count, latest_updated_datetime, next_cursor, has_more, persisted, embedded }`.

### 3. Poll incrementally with `updated_since` / `latest_updated_datetime`

For scheduled or repeat runs, persist the `latest_updated_datetime` returned by each sync and pass it back as `updated_since` on the next run to fetch only tickets changed since the last check. Use `cursor` (a prior call's `next_cursor`) to continue a large backfill in the same session; `has_more` tells you whether another page remains.

### 4. Search tickets in natural language with `search_support_tickets`

`search_support_tickets` is **free**. It searches the `support_tickets` table semantically over each ticket's conversation text and returns full ticket rows ranked by relevance — the right tool for 'what are customers complaining about regarding <product>?' or 'find tickets about shipping delays'. Searches only what's already been synced, so run `gorgias_sync_tickets` first if the data may be stale.

### 5. Narrow with the SQL `filters` clause

Pass an optional SQL `filters` clause over the structured columns to scope a search — e.g. `status`, `channel`, `customer_email`, `ticket_created_at` / `ticket_updated_at` (TIMESTAMP), `tags` (JSON). Example: `search_support_tickets(query='damaged on arrival', filters="status = 'open' AND ticket_created_at > '2026-06-01'")`.

### 6. Count and aggregate with `query_data`

For pure counts or aggregations — ticket volume per day, a breakdown by status or channel — use `query_data` (Gentic Data MCP) over the `support_tickets` table rather than semantic search. Semantic search ranks by relevance; `query_data` is for exact GROUP BY / COUNT analytics over the same rows.

### 7. Present results clearly

Don't dump raw JSON. Summarize the tickets — subject, customer, status, and the gist of the conversation — and surface the `count`. After a sync, tell the user how many tickets were `persisted` and `embedded`. For recurring checks, remind the user you'll track `latest_updated_datetime` so the next run only pulls new and updated tickets.

## Notes

- Organization-scoped: the Gorgias connection comes from the org's connected integration (dashboard → Integrations → Gorgias). No credential is ever passed to the tools.
- Cost: `gorgias_sync_tickets` is **1¢ per synced ticket**; `search_support_tickets` is **free**. Pricing is pulled live from the Gentic MCP manifest.
- `search_support_tickets` only sees tickets already synced into `support_tickets` — run `gorgias_sync_tickets` first, and re-run incrementally to keep results current.
- Tickets are deduped on the Gorgias ticket id: re-syncing an updated ticket refreshes the same row (mutable fields and all) rather than duplicating it.
- For scheduled polling, persist `latest_updated_datetime` and pass it back as `updated_since` — that's the supported incremental pattern.
- Use `search_support_tickets` for 'find/what about' questions and `query_data` over `support_tickets` for counts and aggregations.

## Tool details

- `gorgias_sync_status` — Check the status of an async gorgias_sync_tickets chunk by its `job_id`. Returns `{ status: 'processing' | 'completed' | 'failed' }`, and when completed the chunk result: `{ count, next_cursor, has_more, latest_updated_datetime, timed_out }`. Use this when you didn't pass a `webhook_url` to gorgias_sync_tickets: poll until status is 'completed', then save `next_cursor` and call gorgias_sync_tickets again with it until `has_more` is false. Free.
  - `job_id` (string, required) — The job_id returned by a gorgias_sync_tickets call.
- `gorgias_sync_tickets` — Sync support tickets from Gorgias into this organization's Brain (the per-org `support_tickets` table) — ASYNC, one chunk per call. Uses the org's connected Gorgias integration (dashboard → Integrations); no API key is passed here. Returns immediately with `{ job_id, status: 'processing' }`; the actual work (pull a page of tickets, fetch messages, embed, upsert deduped on the Gorgias ticket id) runs off-box and the chunk result — INCLUDING `next_cursor`, `has_more`, `latest_updated_datetime`, `count` — is delivered when done. Provide `webhook_url` to have that result POSTed to you (the recommended flow for n8n: save `next_cursor` from the webhook and call again with it until `has_more` is false); without a `webhook_url`, poll `gorgias_sync_status` with the returned `job_id`. Two modes via `mode`: 'incremental' (default) pulls NEWEST-FIRST — right for 'the most recent N tickets' (`limit: N`, no `updated_since`), for a date-bounded backfill (`updated_since: '2025-01-01T00:00:00Z'`, then page with `next_cursor`), and for ongoing polling (pass back `updated_since`); 'backfill' walks OLDEST-FIRST through full history via `cursor`. Billed 1¢ per ticket actually synced (charged when the chunk completes, not at dispatch).
  - `limit` (integer) — Max tickets to sync in this chunk (1–100, default 25). Each ticket incurs a messages fetch + an embedding and requests are rate-limit-paced, so the worker chunks; page with `next_cursor` for more.
  - `mode` (string, enum: `incremental` | `backfill`) — 'incremental' (default): newest-first; with no `updated_since` returns the most-recent `limit` tickets, with `updated_since` returns only tickets changed since (paged newest→oldest to the watermark). 'backfill': oldest-first walk through ALL history via `cursor`.
  - `updated_since` (string) — INCREMENTAL mode only. High-water mark (ISO-8601). Only tickets with `updated_datetime` strictly newer than this are synced. Omit for the first/full pull. When a poll finds nothing new, the returned `latest_updated_datetime` may be null — keep your PREVIOUS watermark in that case.
  - `cursor` (string) — Resume cursor — pass a prior chunk's `next_cursor` to continue the same walk (the primary control for backfill, and for paging a large incremental pull). Omit to start a fresh walk.
  - `webhook_url` (string) — Where to POST the chunk result when it completes: `{ job_id, status, count, next_cursor, has_more, latest_updated_datetime, timed_out, table }`. The recommended n8n flow — your webhook receives this, saves `next_cursor`, and fires the next call with it until `has_more` is false. If omitted, poll `gorgias_sync_status` with the `job_id` instead.
- `search_support_tickets` — Search this organization's support tickets by natural language — the right tool for 'what are customers complaining about regarding <product>?', 'what themes are we seeing this week?', 'find tickets about shipping delays'. Searches the `support_tickets` table (populated by gorgias_sync_tickets) semantically over each ticket's conversation text, returning full ticket rows ranked by relevance. Supports an optional SQL `filters` clause over the structured columns to narrow results — e.g. status, channel, customer_email, ticket_created_at/ticket_updated_at (TIMESTAMP), tags (JSON). Example: search_support_tickets(query='damaged on arrival', filters="status = 'open' AND ticket_created_at > '2026-06-01'"). For pure counts/aggregations (group by status, ticket volume per day), use query_data over the support_tickets table instead.
  - `query` (string, required) — Natural-language search query, e.g. 'shipping delays and damaged packaging' or 'complaints about the new subscription flow'.
  - `filters` (string) — Optional SQL filter clause (the body of a WHERE) over structured columns: status, channel, via, customer_email, customer_name, ticket_created_at, ticket_updated_at, message_count, csat_score. Read-only; write/file functions are rejected. Example: "status = 'open' AND ticket_updated_at > '2026-06-01'".
  - `limit` (integer) — Number of tickets to return (1–50, default 10).

---

_This SKILL.md is generated from the live Gentic MCP manifest. Tool names, descriptions, and pricing are always current. Connect Gentic Support at https://gentic.co/support._