<quick_start>

Start with ask_agent — natural language handles most questions (revenue, calls, products, pricing).
Direct lookups → the "All Available Tools" table below (sales_brief for a customer, weekly_brief for the tracker, qualify_lead for inbound, query_dataset for repeatable numbers, execute_sql to READ rows, export_query_csv for a FILE).
Search by meaning: search_account_text (notes + tickets + emails), search_calls (what was SAID), search_companies_by_description (look-alikes). clari_list_calls lists calls by rep/date and is the only route to booked meetings.
Namespace: default to Epiphan Ai, not the Epiphan CRM subset. In Claude Code the tools are mcp__claude_ai_Epiphan_Ai__<tool>.
Deeper reference in this skill's folders:
- resources/ — crm-tools.md, sales-tools.md, enrichment-tools.md, product-tools.md, calendar-tools.md, marketing-tools.md
- reference/ — tool-examples.md (worked examples), verticals.md (persona pack), epiphan-knowledge.md (docs connector), limits.md (read/write ceilings + access requests)
Customer-facing assets → defer to the epiphan-brand-assets-skill (separate Epiphan Brand MCP). </quick_start>

What You Can Do

Sales & Revenue

Ask anything about sales data. Revenue, customers, products, trends — from 2010 to today. All currencies auto-converted to USD.

"Top 10 customers by revenue in 2025" "Monthly sales trend for Pearl Mini last 2 years" "Compare Q1 vs Q2 by region" "Which products have declining sales?" "Pearl Nano vs Pearl Mini revenue comparison" "New customers acquired in 2025" "Customers who haven't ordered in 6 months" "Average order value by customer segment" "80/20 analysis — who are the customers driving 80% of revenue?"

Customer Deep Dive

Get a complete picture of any customer in one shot. Just say the name — fuzzy matching handles misspellings.

"Sales brief for B&H Photo" "Tell me everything about Stanford University" "Customer brief for University of Toronto"

Returns: company info, 12-month revenue, top products, open deals, key contacts, recent notes.

Look up specific orders or history:

"Show B&H Photo order history" "Find order PO-2024-1234" "All orders for customer ID 5678 in 2024"

What we already know about an account (notes + tickets + emails)

Search everything anyone has written about accounts, by meaning. Rep notes, support tickets and customer EMAILS in one corpus, searched together. Before this, the only way in was to open one account and read it.

Emails were added 2026-08-03 and are the bulk of the corpus — roughly 130k qualifying messages against ~10k notes and ~14k tickets — so a question like "who mentioned Panopto" now reaches what was actually said to customers, not just internal notes. Their quoted thread history is stripped, so an excerpt is what that message added rather than the whole conversation replayed.

"Which accounts mentioned Panopto or Kaltura?" "Who talked about budget for next fiscal year?" "What problems have we had with Pearl Nano firmware, and at which accounts?" "Why did this customer return a unit?" "TSJ700304" — paste a serial, RMA or case number and it finds the exact ticket

Returns per hit: the account, the date, the author, the sentence, and whether it came from a rep note, a ticket or an email (e.g. Universiteit Leiden out for tender between Panopto and Kaltura).

Read the attributed_via field. It says how the text was tied to that account: ticket_company and note_company are direct associations somebody made deliberately; note_contact, note_deal and note_ticket are inferences. Treat an inferred link as a lead to check, not a stated fact.

Coverage, so you know what a silent answer means: a note has to be over 100 characters and be traceable to an account (about three notes in four qualify); a ticket needs real content. Anything said only on a call is in search_calls instead, not here.

Find accounts by what they do

Describe the customer instead of naming them. Hybrid keyword plus meaning search over company name, industry and description.

"Find accounts like Duke that we don't sell to yet" "Universities running hybrid classrooms" "AV integrators doing live events"

Set onlyGreenfield for prospecting (accounts that were never in a sales motion). Roughly 40k of our ~55k companies carry a description long enough to search by meaning; the rest can only match on their name or industry.

What was said on recorded calls

Searches call content, not call counts or titles.

"Who mentioned a competitor on a call this quarter?" "Calls where pricing was an objection"

Different from clari_list_calls, which finds calls by rep, attendee or date (and is the only way to see BOOKED/upcoming meetings). search_calls searches what was actually discussed; ask_agent reaches it too.

When may I call this person

Time zones are in the data now — over 100k contacts carry one, covering almost all of the dialable North American pool.

"Who can I call right now at NA gold accounts?" "Contacts at higher-ed accounts in Pacific time"

The answer names its source: the person's own zone, the zone most of their colleagues are in, or their employer's location. Those agree about 71% of the time, which is enough to avoid dialling someone at 3am and not enough to schedule to the minute. Always show it.

Call Prep & Handoffs

Before a call — get fully prepared:

"Sales brief for MIT" "Search Clari for calls with mit.edu in the last 90 days" "Show engagement timeline for MIT — last 6 months" "What's the deal pipeline for MIT?"

After a call — hand off to AE:

"Create AE handoff for MIT, contact: john.smith@mit.edu"

Generates: bottom line summary, pre-call tasks for AE, aggregated intel from CRM + devices + Clari calls + HubSpot engagement. Optionally creates a HubSpot note.

Optional ebStrategy block — when provided, it's appended to the handoff note as an "Economic Buyer Strategy" section AND written to the deal's eb_intel custom properties:

ebTitleHypothesis — hypothesized EB title (e.g. "VP Academic Affairs")
ebPriorityHypothesis — which EB priority the pain maps to
championActivationStatus — exploring | activated | pursuing
doubleUpfrontSeeded — boolean
knownEvalSteps — string array (e.g. IT security review, faculty pilot)

Omit ebStrategy and the handoff is unchanged (backward-compatible). HubSpot writes are admin-scoped.

BDR Call Activity & Coaching

"How many calls did Tim make today?" "Dials to connect ratio for the BDR team this week" "Total talk time by rep this month" "Who did rhaynes call yesterday?" "Any booked demos from calls this week?" "Rep leaderboard for the last 30 days"

Clari call intelligence:

"Summarize Clari calls about Nexus products" "Get summary for call ID 12345" "Search Clari for calls with competitor mentions"

Task Briefs (Sales Rep Accountability)

See overdue + upcoming HubSpot tasks per rep. Highlights "follow up on sales related support ticket" tasks (auto-created from CS_Tickets pipeline) — most commonly missed.

"Task brief for Tim" "Show overdue tasks for Lex Evans" "Team task brief"

Returns: overdue / due-today / upcoming with deal context.

AE Drift Detection

Find contacts and deals that drifted away from a rep. Useful for handoff tracking and pipeline hygiene — surfaces records currently owned by other AEs where the target rep had recent engagement.

"What drifted away from Phillip in the last 7 days?" "AE drift check for Lex"

days lookback: min 1, max 30, default 7.

Lead Qualification

Qualify inbound leads automatically. Detects junk, classifies against ICP, routes to region, drafts outreach email.

"Qualify lead 12345" "Is contact 67890 a good lead?" "Classify and write email for HubSpot contact 11111"

Returns: category (ideal_mql / warm_lead / nurture / junk), confidence score, region (NA/EMEA/APAC), power_level (atl / btl / unknown — above/below the line buyer authority), suggested email draft.

writeToHubSpot defaults to false — qualify_lead is a dry run unless you pass writeToHubSpot: true, which then updates the lifecycle stage + creates a qualification note. Writing is admin-scoped (Tim / Victor).

powerLevelOverride (atl | btl | unknown) — override the title-based ATL/BTL classifier when you know the contact's real authority. Sticky on the contact: later classifier runs won't downgrade it.

Contact Enrichment

Find phone numbers and emails for prospects.

"Find contact info for John Smith at Stanford" "Enrich contact: Sarah Johnson at Microsoft" "Look up email for this person"

3-tier lookup: cached data (instant) → HubSpot DB (instant) → Clay API (30-90s for new contacts). Provide LinkedIn URL for best accuracy.

Company Identification

Match spoken or misspelled company names. Great after sales calls when you're not sure about the spelling.

"Who is be an age photo?" → finds B&H Photo "Identify company: samsun" → finds Samsung "Match this company: standford univeristy"

Returns best matches from CRM + HubSpot with confidence scores.

Device Analytics (Pearl Fleet)

Pearl device registrations, usage, and fleet analysis. Data synced daily from production.

"How many Pearl devices does MIT have?" "Find all devices registered by john@mit.edu" "Devices registered in Germany with high idle rate" "Show idle devices over 90 days for education vertical" "Universities with most device registrations" "Registration trends by country last 12 months" "Devices active per day — last 30 days" "Most active Pearl devices by usage"

Cross-data (devices + revenue):

"Customers with registered devices but no orders in 2024" "Correlation between device count and order value" "Which accounts have devices but no open deal?"

HubSpot CRM

Contacts, companies, deals — search and lookup.

"Search HubSpot for contacts at stanford.edu" "Find deals with 'Nexus' in the name" "Show open deals for company ID 12345" "HubSpot company details for domain mit.edu" "What's the pipeline summary?" "Stalled deals over 30 days"

Product Knowledge

Ask about Epiphan products — pricing, specs, features, comparisons, troubleshooting.

"What's the price of Pearl Mini?" "How much does Epiphan Edge cost for 10 devices?" "Does Pearl-2 support 4K? Is there an extra cost?" "How do I set up Pearl Mini with Panopto?" "What's the difference between Pearl Nexus and Pearl Mini?" "Which encoder is best for NDI workflows?"

Uses structured product catalog (instant) + RAG over Epiphan's official user guides for deep technical questions. Live CRM prices for pricing queries.

The same documentation is also published standalone as the public Epiphan Knowledge connector (kb.epiphan.com, no auth) — see the section near the end. You don't need it here; it's for people working without CRM tools.

Clari Call Search (by Name)

Find calls by company name, contact name, or topic — not just by email.

"How did the Tufts University call go with Jesse Anderson?" "Find calls about Old Dominion" "What was discussed on the Stanford call last week?" "Summarize Lex Evans' calls this month"

Searches the clari_calls table in PostgreSQL (7K+ calls with AI summaries, action items, competitor mentions).

Stripe Cloud Usage

Epiphan Cloud (Connect/Unify) usage tracking and renewal alerts.

"Which customers are approaching their usage contract limits?" "Show Stripe usage for PLI" "Cloud usage growth signals — who's increasing?" "Churn risk: customers with declining usage"

Curated Analytics Datasets (Weekly Tracker / Repeating Reports)

Parameterized analytics with deterministic SQL — built for recurring reports (Cowork weekly sales tracker, BDR digests). Bypass ask_agent when you need consistent numbers.

5 datasets, common filters + group_by:

Dataset	What	Example
`revenue`	CRM orders, USD-converted, `order_type_id < 30`	"Booked revenue MTD/QTD/YTD"
`deals_closed`	HubSpot won/lost in date range	"Won deals last week, by outcome"
`pipeline_open`	HubSpot active pipeline (excludes closed)	"Open pipeline by AE × stage"
`contacts_created`	New HubSpot contacts with lifecycle/source	"New leads by lifecycle this week"
`rep_activity`	BDR/AE engagements (emails, calls, tasks, meetings, notes)	"Tim + Ron activity last 7 days"

"Use query_dataset: revenue from 2025-11-01 to 2026-04-29 by month" "Open pipeline matrix — AE × stage for default sales pipeline" "Won/lost deals last week, split by outcome" "New contacts last week broken down by lifecycle and source" "BDR activity for owner_ids 87486452, 423155215 last 7 days"

group_by supports cross-product matrix (e.g. ["owner","stage"]), period grain (period_day / period_week / period_month / period_quarter / period_year), and dimensional breakdown (owner / stage / outcome / country / lifecycle / source / pipeline). format=csv returns an embedded CSV file (Claude Desktop attaches it). Custom HubSpot lifecycle stage IDs are normalized to MQL/SAL/SQL/Customer/Junk/Declined/Nurture labels.

Slash commands (prompts) — the shortest path in

Three ready-made prompts, shown as slash commands; each encodes the step order that avoids the mistakes below.

command	what it does
`crm-sql`	Answers a question with SQL: reads the schema first, then queries. Give it the question.
`account-brief`	Everything about one account — orders, deals, registered devices, recent activity. Give it a company name or domain.
`export-list`	Builds a list and hands it back as a CSV file. Give it the list you want, optionally a filename.

If you don't see them, reconnect the connector — prompts arrive at connection time.

The schema, without spending a tool call

Two resources your client can read directly:

crm://schema.md — every queryable table and column with its business meaning.
crm://schema/{table} — one table, e.g. crm://schema/hubspot_deals. Use this when you just need to check a couple of column names; the whole document is well over 100KB.

Both are generated live (never stale); get_schema returns the same content as a tool call. Why it matters: a guessed column name is the commonest failure. Recurring trap — stage lookups join pipeline_id = pipeline plus stage_id = dealstage for deals but stage_id = pipeline_stage for tickets.

Raw SQL Export

Reading rows: execute_sql. Runs a read-only SQL SELECT and returns the rows as JSON with types intact — 500 by default, 1 000 at most, and truncated: true when that bound is what stopped it. This is the one to use when you want DATA. Pair it with list_tables and get_schema: a guessed column name is the single most common reason a query fails here, and both tools exist to stop that.

Escape hatch when you want a FILE. export_query_csv runs the same read-only SQL and returns the result as a CSV — attached to the reply when it is small, or as a download_url link when it is over ~1MB, so a multi-megabyte export never lands in your context. files[].delivery says which you got.

"Export this query as CSV: SELECT ... FROM crm_orders WHERE ..."

Same SQL safety as execute_sql — the same validator and the same read-only DB role (SELECT/WITH only, no writes, no INSERT/UPDATE even inside a WITH). 50 000 rows is a cap PER CALL, not a dead end — a bigger result set is paged: the response carries has_more and next_offset, so re-run the same SQL with offset: <next_offset> until has_more is false. Each page comes back as its own file (export.csv, export_50000.csv, …).

Paging requires a deterministic top-level ORDER BY, ideally ending in a unique column (ORDER BY created_at DESC, id). Without one Postgres may order rows differently per page, so pages would silently repeat and skip records — the tool refuses rather than hand you a plausible-looking wrong export. Don't write LIMIT/OFFSET yourself for paging; use max_rows + offset.

Data Visualization

Generate Economist-style charts from any data (generate_image) — "bar chart of top 10 customers by revenue", "line chart: monthly revenue 2023-2025". Always provide the data (JSON/table) with the request.

All Available Tools

Tool	What it does
`ask_agent`	Ask any CRM/analytics question in natural language
`sales_brief`	Complete customer briefing in one call
`ae_handoff`	BDR→AE handoff package with HubSpot note
`qualify_lead`	Lead qualification: junk detection, ICP scoring, email draft
`identify_company`	Fuzzy match company names across CRM + HubSpot
`enrich_contact`	Find phone + email via Clay
`activity_get_timeline`	Engagement history (calls, emails, notes, meetings)
`search_account_text`	What was WRITTEN about accounts — rep notes + support tickets + emails, hybrid meaning + keyword. Params: `query`, `source` (note\|ticket\|email), `companyId`, `sinceDays`, `limit`. For emails, `source` also tells you the direction — we wrote it vs the customer did. A pasted serial/RMA/case number finds its exact ticket. Every hit carries `attributed_via`, which says whether the account was a direct association or an inference through a contact or ticket
`search_companies_by_description`	Accounts by what they DO — look-alikes from a description. Params: `query`, `onlyGreenfield`, `limit`. NOT `hubspot_search_companies` (name/domain) and NOT `identify_company` (one known name)
`search_calls`	What was SAID on recorded calls — hybrid keyword+semantic over the ~7.8k recorded calls we hold (nearly everything Clari recorded; about 4 in 10 carry a summary, and only those are content-searchable). Does NOT see booked/upcoming meetings — use `clari_list_calls` for those
`clari_list_calls`	LIST calls by rep, attendee, date or status, live from the Clari API — the only route to BOOKED/upcoming meetings (17,136 SCHEDULED entries exist only there). Was `clari_search_calls` until 2026-07-27; renamed because it never searched content
`clari_get_call`	Full call details + optional transcript
`clari_get_call_summary`	Quick call summary + action items
`hubspot_search_companies`	Find HubSpot companies
`hubspot_get_company`	Company details by ID
`hubspot_search_contacts`	Find HubSpot contacts
`hubspot_get_contact`	Contact details by ID
`hubspot_find_contacts_by_role`	Role discovery — "who is the AV/IT Director at northeastern.edu". Keyed on email domain (ignores dirty company names). Params: `domain`, `titles[]` (optional; defaults to higher-ed AV/IT preset), `limit`. Unions HubSpot + Clay-enriched contacts, decision-makers first. Read-only. Use this for list-building instead of enrich_contact (which needs a known name)
`hubspot_search_deals`	Find HubSpot deals
`hubspot_get_deal`	Deal details by ID
`crm_get_customer`	Legacy CRM customer by ID
`crm_search_customers`	Search legacy CRM customers
`crm_get_order`	Order details (fuzzy search)
`crm_get_customer_orders`	Customer order history
`analytics_get_device`	Pearl device lookup by serial
`analytics_search_by_email`	All devices by registrant email
`search_product_catalog`	Product pricing, specs, features, competitors (catalog + CRM prices + RAG)
~~`search_product_knowledge`~~	Removed from `Epiphan Ai` on 2026-08-15. `search_product_catalog` already queries the same wiki AND resolves which product you mean; having both let the model answer about the wrong product. For docs-only questions use the public `Epiphan Knowledge` connector
`task_brief`	Overdue + upcoming HubSpot tasks per rep (or team)
`ae_drift_detect`	Contacts/deals reassigned away from a rep (last N days)
`query_dataset`	Curated parameterized analytics: revenue, deals_closed, pipeline_open, contacts_created, rep_activity
`weekly_brief`	One-shot weekly sales tracker — bundles 9 `query_dataset` calls. Params: `week_ending`, `ae_names`, `bdr_owner_ids`, `fiscal_year_start`, `target_annual_revenue`, `pipelines`. Defaults: FY2026, Tim+Ron, $19.5M target
`execute_sql`	Raw read-only SQL → rows as JSON (500 default / 1 000 max). Use this to READ data
`list_tables`	The tables you may query — call before writing SQL
`get_schema`	Columns of the tables you name — a guessed column is the commonest failure
`export_query_csv`	Raw read-only SQL → CSV file (attached, or a `download_url` link over ~1MB). 50k rows per page — page past it with `offset` + `next_offset` (needs a top-level `ORDER BY`)
`generate_image`	Data charts and infographics

Calendar & booking → `resources/calendar-tools.md`

Seven tools handle meetings: get_upcoming_meetings, get_booking_link, book_group_meeting, schedule_on_my_calendar, cancel_on_my_calendar, move_on_my_calendar, manage_booking. They all act on the caller's own calendar and preview before acting.

Read resources/calendar-tools.md before using any of them — which one to reach for is the whole problem, and one wrong choice (cancelling a book.epiphan.com call with cancel_on_my_calendar) silently corrupts our booking records.

HubSpot Write Tools (admin-scoped: Tim / Victor)

These mutate HubSpot. Restricted to an allowlist — others get a 403. Rate-limited: 1,000 writes / 5 min per user (bulk-friendly), 4 / 5 min per record. See Limits below for the read side and for how to ask when a ceiling is in your way.

Tool	What it does
`hubspot_create_contact`	Create contact. Idempotent — dedupes by email (returns existing on match). Entry stages only (lead/MQL/SQL/Cold Lead/SAL); accepts `associateCompanyId`
`hubspot_create_company`	Create company. Dedup is domain-first: any existing company on the same registrable domain (eTLD+1 — `www.carleton.ca`, `cunet.carleton.ca` and `carleton.ca` all match) is flagged as the same institution (`needsReview:true`, `matchType:"domain"`), since that's the reliable key for dirty higher-ed names. Falls back to fuzzy company-name match on other domains. Reuse a candidate's `companyId`, or pass `confirmDespiteSimilar:true` to force-create a genuinely distinct org
`hubspot_create_deal`	Create deal. No dedup — pass `pipelineId` + `dealstage` (from `hubspot_deal_stages`)
`hubspot_update_contact`	Update fields on an existing contact (e.g. add a missing phone). Identify by `contactId` or `email`. Patches only the fields you pass: `phone`, `mobilephone`, `jobtitle`, `firstName`, `lastName`, `company`, `website`. Owner → use `hubspot_update_contact_owner`; lifecycle → `hubspot_set_lifecycle_stage`
`hubspot_update_company`	Update fields on an existing company. Identify by `companyId` or `domain` (ambiguous domain → returns candidates, pass `companyId`). Patches only passed fields: `name`, `address`, `city`, `state`, `zip`, `country`, `industry`, `phone`, `website`. The company read tools return the same fields, so you can check a value before overwriting it
`hubspot_update_contact_owner`	Set contact owner. Validates `ownerId` against `hubspot_owners`
`hubspot_set_lifecycle_stage`	Set lifecycle stage. Accepts ID, label, or alias (SAL/MQL/Cold Lead) — resolved + validated
`hubspot_create_contact_note`	Create note on a contact (optionally on deal/company). HTML body, script tags stripped
`hubspot_create_contact_task`	Create task on a contact. ISO 8601 due date, validated `ownerId`. `taskType`: `CALL` / `EMAIL` / `TODO` (default TODO) — pass `CALL` for dial/follow-up-call tasks (Nooks call lists) so they land as real Call tasks. No HubSpot connector needed
`hubspot_update_contact_note`	Edit an existing note's body by `noteId`. HTML, script tags stripped + spacing normalized. Guardrail: only notes our integration created, or ones newer than ~7 days, can be edited — older human-authored notes are protected (`Forbidden`). HubSpot keeps per-property history as a backstop
`hubspot_update_contact_task`	Edit an existing task by `taskId`. Any subset of `subject` / `body` / `dueDate` / `status` / `ownerId` / `taskType` / `priority`; omitted fields unchanged. `status: COMPLETED` marks it done. Same age/ownership guardrail as note updates

HubSpot Static Lists (admin-scoped)

Push a BDR segment to a HubSpot static (MANUAL) list instead of CSV/Sheets import. Created list names are stamped with an [AI] prefix so humans can spot agent-managed lists in the UI.

Tool	What it does
`hubspot_search_lists`	Read. Find lists by `query` (substring) or exact `name` (case-insensitive). Returns `listId` (ILS), `name`, `processingType`, `size`. `objectType`: contacts/companies/deals
`hubspot_list_members`	Read. List a list's members joined to the mirror for that list's object type — check `objectType` in the response. Contacts → name/email/company/jobtitle/phone; companies → name/domain/industry/country/lifecyclestage; deals → dealname/dealstage/pipeline/amount/closedate/owner. Per-member gap flags mark blank enrichable fields (contacts: jobtitle/phone, companies: domain/industry) + a summary; `gapsOnly: true` returns just those. Use with `enrich_contact` to fill only the gaps (e.g. what the HubSpot/Breeze agent left partially filled) — saves Clay credits, doesn't re-enrich complete contacts. Works on any list. `inSync:false` on a member means that record isn't mirrored locally yet, not that the list is empty
`hubspot_create_list`	Create a MANUAL list. Idempotent — dedupes by name (forced `[AI]` prefix). Optional `recordIds` seed (max 5,000, auto-chunked ≤500/request). Reuses an existing agent-owned list; on a name clash with a human-made list it returns the ID but refuses to seed (`LIST_NOT_AGENT_OWNED`)
`hubspot_update_list_membership`	Add/remove records (`add`/`remove`, combined max 5,000, auto-chunked into ≤500/request). Only on lists the agent created itself — refuses any other list (`LIST_NOT_AGENT_OWNED`) and non-MANUAL lists (`LIST_NOT_MANUAL`). Natively idempotent (already-member / non-member IDs reported as `missing`); a mid-batch failure returns `PARTIAL_FAILURE` with what landed — just re-run

Why the ownership lock: a static-list membership can be a HubSpot workflow enrollment trigger. The agent can only mutate lists it created — so it can never inject members into a human-curated list that might fire a campaign. Lists created here are immediately queryable by the official HubSpot connector via hs_crm_search.ilsListIds.

Note: Stripe Cloud usage queries (renewals/growth/churn) go through ask_agent — there's no dedicated MCP tool. Just ask in natural language.

Namespaces — default to `Epiphan Ai`

Two MCP connections may show up:

Epiphan Ai — the full toolset above. Default to this.
Epiphan CRM — a subset. Missing, among others: hubspot_get_contact, crm_get_customer_orders, get_upcoming_meetings, weekly_brief, hubspot_search_contacts, and the collaborator_owner_id filter on hubspot_search_deals.

If a tool seems "missing," you're probably on Epiphan CRM — switch to Epiphan Ai. (hubspot_search_contacts exists — it just isn't exposed on the CRM subset.)

Marketing analytics is not here. Semrush, GA4 and Google Ads live on their own connector (/api/mcp/marketing) and are not reachable from Epiphan Ai — ask_agent cannot see them either. Asking this server for a Semrush report returns nothing rather than an error, which is why it is worth saying out loud. In Claude Code they are the Epiphan Analytics connector (mcp__claude_ai_Epiphan_Analytics__*) — see resources/marketing-tools.md.

Product documentation → the separate `Epiphan Knowledge` connector

Official Epiphan product docs live on a public, authless MCP server (https://chat.epiphan.com/api/mcp/knowledge/mcp, web kb.epiphan.com). Three tools: search, fetch (one page verbatim by <product>/<topic-slug> id), submit_feedback. In Claude Code: mcp__claude_ai_Epiphan_Knowledge__*.

Question	Where
Specs, setup, firmware, troubleshooting ("Does Pearl Nexus support NDI?")	`Epiphan Knowledge`, or `search_product_catalog` inside `Epiphan Ai` (same wiki, resolves the product first)
Price, SKU, lifecycle, competitors	`search_product_catalog` in `Epiphan Ai` (live CRM prices)
Anything about accounts, deals, usage	`ask_agent` in `Epiphan Ai`

Name the product and ask multi-product questions one product at a time — docs are mixed-model. Report doc gaps in #ai-kb-training-issues. Full section: reference/epiphan-knowledge.md.

Creating customer-facing assets → use the `epiphan-brand-assets` skill

Brand lives on a separate Epiphan Brand MCP server (voice, tokens, personas, product positioning, logos, fonts) and has its own dedicated skill. Before drafting any customer-facing asset (email, one-pager, deck, proposal) — and before any external send — defer to the epiphan-brand-assets skill, which drives the brand tools (get_brand_asset_kit, check_my_copy, …) end-to-end. Don't hand-roll brand calls from this CRM guide.

Limits — and what to do when you hit one

Three ceilings, none a permission problem: daily read budget (added 2026-09-08: 100 rows/day with no read grant, 1,000 for sales crm-read, unlimited for full tier/admin; a spent budget still answers 50 rows per call until midnight), Knowledge connector 30 searches/min, HubSpot writes 1,000 / 5 min per user and 4 / 5 min per record. A refusal files itself as an access request — Rustam or Victor sees it; bulk-read raises the row band, crm-read adds the data grant. Details and the reasoning: reference/limits.md.

Good to Know

Start with ask_agent — it handles most questions including calls, products, revenue. Use specific tools only for direct lookups.
Call search works by name — "how did the Tufts call go?" finds it via company/contact name (not just email).
Product questions — ask_agent uses product catalog + RAG. For pricing it pulls live CRM prices.
Fuzzy matching works — don't worry about exact spelling for company names.
qualify_lead is a dry run by default — pass writeToHubSpot: true to update lifecycle + create the note (admin-scoped).
ae_handoff with createNote: true — visible to the entire sales team.
HubSpot IDs are strings, CRM IDs are numbers.
First enrich_contact call for a new person takes 30-90s (Clay API). Subsequent calls are instant.
Clari clari_get_call — skip includeTranscript for faster responses.
Be specific about time periods — "2024", "last 6 months", "Q3 2025".
Specify metrics — "revenue", "order count", "average order value".
Specify grouping — "by country", "by month", "by product family".

<success_criteria>

The question was routed to the right tool (or ask_agent) on the first try, using the tool table + resources/ guides
Epiphan Ai namespace used (not the Epiphan CRM subset) when a tool seemed "missing"; marketing questions sent to the Epiphan Analytics connector, product-docs-only questions to Epiphan Knowledge
Tool defaults and caveats respected: qualify_lead dry-run unless writeToHubSpot:true, ae_drift_detect max 30 days, HubSpot IDs as strings, write tools admin-scoped (Tim/Victor), [AI] list ownership lock, export_query_csv paging via offset + deterministic ORDER BY
Schema checked (crm://schema, list_tables, get_schema) before any hand-written SQL; execute_sql for rows, export_query_csv only for a file
Repeating reports used query_dataset / weekly_brief (deterministic SQL), not ad-hoc ask_agent
Customer-facing asset requests deferred to the epiphan-brand-assets-skill; a limit refusal reported as a filed access request, not a permissions failure </success_criteria>

Emit Outcome Sidecar

When this guide drove a tool-routing decision, write ~/.claude/skill-analytics/last-outcome-epiphan-ai-mcp-guide-skill.json: {"ts":"[UTC ISO8601]","skill":"epiphan-ai-mcp-guide-skill","version":"1.1.0","variant":"default","status":"[success|partial|error]","runtime_ms":[ms],"metrics":{"tools_routed":[n],"namespace_corrections":[n],"limit_refusals":[n]},"error":null,"session_id":"[YYYY-MM-DD]"}

epiphan-ai-mcp-guide-skill

Epiphan AI — MCP Tools Guide