---
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_tickets` | Sync support tickets from Gorgias into this organization's Brain (the per-org `support_tickets` table). Uses the org's connected Gorgias integration (dashboard → Integrations); no API key is passed here. Two modes via `mode`: 'incremental' (default) pulls NEWEST-FIRST and is right for 'the most recent N tickets' (`limit: N`, no `updated_since`) and for ongoing polling (pass back `updated_since`); 'backfill' walks OLDEST-FIRST through full history via `cursor` (stable + resumable — use this for a one-time historical load). Fetches each ticket's full message thread and upserts deduped on the Gorgias ticket id (a ticket update refreshes the same row). Each ticket's conversation text is embedded so it's semantically searchable via `search_support_tickets` and aggregatable via `query_data`. Requests are paced under Gorgias's rate limit and each call is bounded by a wall-clock budget, so large pulls are chunked: when `has_more` is true (or `timed_out` is true), call again with the returned `next_cursor` (continuing a walk) until `has_more` is false. Returns `{ tickets, count, latest_updated_datetime, next_cursor, has_more, timed_out, persisted, embedded }`. Billed 1¢ per synced ticket. | 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_tickets` — Sync support tickets from Gorgias into this organization's Brain (the per-org `support_tickets` table). Uses the org's connected Gorgias integration (dashboard → Integrations); no API key is passed here. Two modes via `mode`: 'incremental' (default) pulls NEWEST-FIRST and is right for 'the most recent N tickets' (`limit: N`, no `updated_since`) and for ongoing polling (pass back `updated_since`); 'backfill' walks OLDEST-FIRST through full history via `cursor` (stable + resumable — use this for a one-time historical load). Fetches each ticket's full message thread and upserts deduped on the Gorgias ticket id (a ticket update refreshes the same row). Each ticket's conversation text is embedded so it's semantically searchable via `search_support_tickets` and aggregatable via `query_data`. Requests are paced under Gorgias's rate limit and each call is bounded by a wall-clock budget, so large pulls are chunked: when `has_more` is true (or `timed_out` is true), call again with the returned `next_cursor` (continuing a walk) until `has_more` is false. Returns `{ tickets, count, latest_updated_datetime, next_cursor, has_more, timed_out, persisted, embedded }`. Billed 1¢ per synced ticket.
  - `limit` (integer) — Max tickets to sync this call (1–100, default 25). Each ticket incurs a messages fetch + an embedding and requests are rate-limit-paced (~1s/ticket), so prefer modest batches (25 is a good unit for scheduled n8n loops) and 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. 'backfill': oldest-first walk through ALL history via `cursor` — start with no cursor, then pass back `next_cursor` each call until `has_more` is false. Use backfill for the one-time historical load, incremental for hourly polling.
  - `updated_since` (string) — INCREMENTAL mode only. High-water mark — an ISO-8601 datetime (pass the previous run's `latest_updated_datetime`). Only tickets with `updated_datetime` strictly newer than this are synced. Omit for the first/full pull. Ignored in backfill mode. Note for schedulers: when nothing new is found, `latest_updated_datetime` may come back null — keep your PREVIOUS watermark in that case rather than overwriting it with null.
  - `cursor` (string) — Resume cursor — pass a prior call'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.
- `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._