How to build Gong conversation-intelligence dashboards in Metabase

{
  "mcpServers": {
    "gong": {
      "url": "https://your-gong-mcp-endpoint/mcp"
    }
  }
}

# Install the Metabase CLI
npm install -g @metabase/cli

# Log in (opens your browser; requires Metabase v62+)
mb auth login --url https://your-metabase.example.com

# Load a Gong CSV export — creates a table AND a model
mb upload csv --file gong-deals.csv --collection root

# Refresh that same table later from a new export
mb upload replace <table-id> --file gong-deals.csv

Create a polished Metabase dashboard for Gong conversation-intelligence analytics.
Work end to end: get the data into Metabase if it isn't there yet, then build.

Goal: Help sales and enablement leaders understand call coverage, conversation
quality, topic trends, and deal engagement from Gong data — joined to CRM
pipeline where possible.

Step 1 — Find or load the data:
- First, check what already exists in Metabase (search for Gong tables and
  models). If durable Gong data is already present — synced from a warehouse or
  uploaded earlier — use it and skip to Step 2.
- If nothing is there, pull it with the Gong MCP server (read-oriented briefs and
  lookups via ask_account, ask_deal, and generate_brief): calls, deals, tracker
  matches, scorecards, and interaction stats. Write each result to a CSV, then
  load it with the Metabase CLI — run "mb upload csv --file <export>.csv" so each
  upload creates a table and a ready-to-query model. Use "mb upload replace
  <table-id> --file <export>.csv" to refresh an existing table instead of creating
  duplicates.

Step 2 — Inspect before querying:
Gong CSV exports are usually flat and pre-aggregated (one row per deal or rep, with
columns like calls, coverage, talk ratio, and competitor mentions). Warehouse
tables are raw and call-grained (calls, interaction stats, and tracker matches you
join yourself). Inspect the actual tables and column names first; do not assume
exact names or that a call-level table exists.

Important:
- Build on whatever data is present; don't claim Metabase connects natively to
  Gong — it reads a database or CLI-uploaded tables.
- Gong signals are most useful joined to CRM deals — align on a deal/opportunity
  key so coverage and engagement map to real pipeline, when raw counts allow it.
- Define "coverage" explicitly (e.g. open deals with a call in the last N days)
  and hold N fixed.
- Read talk-to-listen ratio and monologue as coaching signals, not targets.
- Only build a card if its underlying column/metric exists in the data.
- A single CSV is a point-in-time snapshot: only build trend cards if there is a
  usable date column or multiple periods have been uploaded.

Dashboard title: Gong Conversation Intelligence Overview

Sections:
1. Executive summary (KPI cards): Call coverage; Calls per open deal; Avg
   talk-to-listen ratio; Deals with a next step; Competitor mentions; Scorecard
   average.
2. Coverage: Open deals with a recent call; calls per deal by stage; no-next-step
   deals.
3. Quality: Talk-to-listen by rep; monologue distribution; question rate;
   scorecards.
4. Topics: Tracker mentions over time; objections by segment; feature requests.
5. Engagement: Engagement score vs. win rate; days since last touch; champion
   engagement.

Filters: Rep, Stage, Segment, Tracker, Date range.

Reuse the models Metabase auto-created from uploaded CSVs, or (for a warehouse)
create reusable models: modeled_gong_calls, modeled_gong_deals,
modeled_gong_tracker_matches, modeled_gong_scorecards, and
modeled_gong_interaction_stats.

Output: Build the dashboard if you have permission; otherwise provide the exact
questions, SQL, model definitions, and layout. Include caveats for any metric
that cannot be calculated from the available data. Reconcile totals against
Gong's own analytics. Keep it practical, dense, and executive-readable.

Open deals with a call in the last 14 days, as a share of open deals.

-- Call coverage: open deals with a call in the last 14 days
SELECT
  d.stage,
  COUNT(*)                                                        AS open_deals,
  COUNT(*) FILTER (WHERE c.last_call_at >= CURRENT_DATE - INTERVAL '14 days') AS covered,
  ROUND(100.0 * COUNT(*) FILTER (WHERE c.last_call_at >= CURRENT_DATE - INTERVAL '14 days')
    / NULLIF(COUNT(*), 0), 1)                                     AS coverage_pct
FROM modeled_gong_deals d
LEFT JOIN (
  SELECT deal_id, MAX(started_at) AS last_call_at
  FROM modeled_gong_calls
  GROUP BY deal_id
) c ON c.deal_id = d.id
WHERE d.status = 'open'
GROUP BY d.stage
ORDER BY coverage_pct;

A coaching signal from interaction stats over the last 90 days.

-- Talk-to-listen ratio by rep (coaching signal)
SELECT
  u.name AS rep,
  ROUND(AVG(s.talk_ratio), 1) AS avg_talk_ratio_pct,
  COUNT(*)                    AS calls
FROM modeled_gong_interaction_stats s
JOIN modeled_gong_users u ON u.id = s.user_id
WHERE s.call_started_at >= CURRENT_DATE - INTERVAL '90 days'
GROUP BY u.name
ORDER BY avg_talk_ratio_pct DESC;

Tracker matches for competitors, split by won/lost/open.

-- Competitor mentions by deal outcome
SELECT
  t.tracker_name,
  d.status,
  COUNT(*) AS mentions
FROM modeled_gong_tracker_matches t
JOIN modeled_gong_calls c ON c.id = t.call_id
JOIN modeled_gong_deals d ON d.id = c.deal_id
WHERE t.tracker_type = 'competitor'
GROUP BY t.tracker_name, d.status
ORDER BY mentions DESC;