gentic

Gentic Support — Documentation

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.

1. Getting Started

Sign Up & Get Your API Key

Before you can use Gentic Support, you need an API key to authenticate your requests.

  1. Go to gentic.co/support and create an account.
  2. Create an organization from your dashboard. API keys and billing are scoped to the organization.
  3. Generate an API key and use it as a Bearer token in your MCP client.

2. Connecting to the MCP Server

The server is available at https://mcp.gentic.co/support. For Claude Code:

claude mcp add gentic-support \
  --transport http \
  https://mcp.gentic.co/support \
  --header "Authorization: Bearer YOUR_API_KEY"

For Claude Web and ChatGPT you can also connect via OAuth — no API key needed. See the connect section on the landing page for other MCP clients (n8n, OpenClaw).

3. Agent Skill

For the best results, pair the MCP server with the Gentic Support agent skill. The MCP server gives your agent tool access; the skill teaches it the optimal workflow order. Both the raw SKILL.md and a ready-to-upload .skill bundle are generated on demand from the live manifest, so they always reflect the current tools and pricing.

Add the skill directly via URL:

https://gentic.co/support/SKILL.md

Or upload a .skill bundle to Claude Managed Agents:

https://gentic.co/support/gentic-support.skill

Download this file and upload it wherever Claude Managed Agents asks for a .skill file. It's a zip bundle generated on demand from the latest SKILL.md.

4. 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.

5. Workflow

  1. 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. 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. 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. 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. 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. 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. 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.

6. Tool Reference

3 tools, rendered live from the Gentic MCP manifest. Parameter tables come directly from each tool's JSON Schema.

gorgias_sync_status

Free

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.

ParameterTypeDescription
job_id
required
string

The job_id returned by a gorgias_sync_tickets call.

gorgias_sync_tickets

1¢ / result

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).

ParameterTypeDescription
limitinteger

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.

1 – 100

modestring

'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`.

enum: incremental, backfill

updated_sincestring

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.

cursorstring

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_urlstring

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

Free

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.

ParameterTypeDescription
query
required
string

Natural-language search query, e.g. 'shipping delays and damaged packaging' or 'complaints about the new subscription flow'.

filtersstring

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'".

limitinteger

Number of tickets to return (1–50, default 10).

1 – 50

7. Pricing

Pricing is pulled live from the Gentic MCP manifest. All prices are per call and deducted from your Gentic credits.

ToolCost
gorgias_sync_statusFree
gorgias_sync_tickets1¢ / result
search_support_ticketsFree

8. 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.