How to build LiveAgent support dashboards in Metabase

LiveAgent is a multi-channel help desk that brings email, live chat, calls, and social messages into one ticketing system. Metabase is where you turn that activity into shared, trustworthy dashboards. This guide covers two complementary paths: a lightweight MCP route for fast, AI-assisted questions, and a durable pipeline route that syncs LiveAgent into a database so you can build dashboards anyone can read.

How do you connect LiveAgent to Metabase?

Most teams combine these: use the MCP route to explore and triage, and the pipeline route for the dashboards people depend on.

What can you analyze from LiveAgent data in Metabase?

• Ticket volume — created vs. resolved by day and channel
• First response time — how long customers wait for a reply
• Channel mix — email vs. chat vs. call vs. social
• Department health — backlog and load by department
• Backlog and aging — open work and how long it's been waiting
• Agent performance — workload distribution and handle time
• Repeat contacts — customers writing in repeatedly

Which LiveAgent dashboards should you build in Metabase?

How do you use the LiveAgent and Metabase MCP servers together?

Pair the LiveAgent MCP server with the Metabase MCP server for live, conversational analysis. The LiveAgent MCP reads current ticket data; the Metabase MCP queries the models and dashboards you've already built.

Example workflows

• List open tickets in the support department and summarize by channel.
• Pull today's unanswered tickets from LiveAgent and compare response trends against a Metabase model.
• Triage: "show tickets with no agent reply in 4 hours."

Be honest about the limits

• MCP is great for live lookups — not for scheduled or audited reporting.
• It does not create history; trend analysis still needs synced data.
• Actions run as your agent identity and appear in the ticket activity history.
• The Metabase MCP server is built in; an admin enables it under Admin → AI → MCP.

How do you set up the LiveAgent and Metabase MCP servers?

{
  "mcpServers": {
    "liveagent": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://YOUR_ACCOUNT.ladesk.com/public/api/mcp"
      ]
    },
    "metabase": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://your-metabase.example.com/api/metabase-mcp"]
    }
  }
}

Replace YOUR_ACCOUNT with your LiveAgent subdomain. For Bearer auth, generate an MCP token in your agent profile and pass it in the Authorization header.

Can you generate a LiveAgent dashboard with AI?

Yes — and this is the fastest way to a strong first draft. Use the prompt below with the Metabase MCP server and any assistant that can inspect your warehouse schema and create Metabase questions. It assumes LiveAgent data is already synced into a database Metabase can read, treats MCP as exploratory, and tells the agent to skip metrics the schema can't support instead of faking them.

Create a polished Metabase dashboard for LiveAgent support analytics using the
available LiveAgent tables in this database.

Goal: Help support leaders understand multi-channel volume, responsiveness,
department health, and agent workload from LiveAgent data.

First, inspect the schema and identify the available LiveAgent tables. Do not
assume exact table names. Map the available raw tables into these analytical
concepts where possible: Tickets, Messages, Agents, Contacts, Departments, Tags,
and Channels (email, chat, call, social).

Important:
- Treat MCP data access as exploratory only.
- Build the dashboard from durable database/warehouse tables.
- Use medians (p50) and p90 for response times, never averages.
- Define "first response" as the first outbound agent message, excluding internal
  notes and automated messages.
- If ticket event history is missing, do not calculate reopen rate or
  time-in-status. Use a caveat instead.
- Do not claim Metabase connects natively to LiveAgent unless that is explicitly
  true in this environment.

Dashboard title: LiveAgent Support Overview

Sections:
1. Executive summary (KPI cards): Tickets created last 7 days; Resolved last 7
   days; Open backlog; Median first response time; Volume by channel.
2. Volume & backlog: Created vs resolved by day; Open by status; Backlog aging;
   Volume by channel.
3. Response time & SLA: First response p50/p90 by week; Open by department;
   Reopened by week (only if history exists).
4. Agent performance: Resolved by agent; Median handle time by agent; Open
   assigned by agent; Calls by agent.
5. Channels & drivers: Volume by channel over time; Volume by tag; Volume by hour;
   Repeat contacts.

Filters: Department, Agent, Channel, Tag, Status, Date range.

Before finalizing, create or recommend reusable Metabase models:
modeled_liveagent_tickets, modeled_liveagent_messages, modeled_liveagent_agents,
modeled_liveagent_contacts, and modeled_liveagent_departments.

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 schema. Keep it practical, dense,
and executive-readable. Avoid vanity metrics.

How do you sync LiveAgent data into a database or warehouse?

For dashboards that need history and reliability, land LiveAgent data in a database first, then connect Metabase to that database.

Connector options

• dlt(code) — write a Python pipeline against the LiveAgent REST API (v3); the most reliable route since there's no first-party managed connector.
• LiveAgent REST API (v3)(raw) — the source of truth; paginate tickets, messages, agents, and departments and upsert on a schedule.
• Managed ETL (verify) — check whether your ETL vendor offers a LiveAgent connector; availability varies, so confirm before relying on it.

Notes

• Land raw tables first, then build clean models on top.
• Sync messages so you can compute response times and channel mix accurately.
• Capture ticket events if you want accurate reopen rate and time-in-status.

How should you model LiveAgent data in Metabase?

Core tables

Modeling advice

• Map LiveAgent's coded statuses and channel types to readable labels in a model — the MCP server does this for you, but raw API data is coded.
• Define first response from the first outbound agent message, excluding notes.
• Treat tags as a bridge table so a ticket can carry many tags.
• Keep call tickets separate where handle time means talk time, not reply time.
• Define "resolved" once and reuse it everywhere.

Which LiveAgent metrics should you track in Metabase?

What SQL powers LiveAgent dashboards in Metabase?

These assume the modeled tables above (PostgreSQL dialect; LiveAgent uses coded statuses such as R for resolved). Adjust identifiers to match your warehouse.

SELECT
  date_trunc('day', t.date_created) AS day,
  COUNT(*)                                          AS created,
  COUNT(*) FILTER (WHERE t.status = 'R')            AS resolved
FROM tickets t
WHERE t.date_created >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY 1
ORDER BY 1;

WITH first_outbound AS (
  SELECT
    m.ticket_id,
    MIN(m.date_created) AS first_reply_at
  FROM messages m
  WHERE m.type = 'A'        -- agent message
    AND m.is_note = false
  GROUP BY m.ticket_id
)
SELECT
  date_trunc('week', t.date_created) AS week,
  percentile_cont(0.5) WITHIN GROUP (
    ORDER BY EXTRACT(EPOCH FROM (f.first_reply_at - t.date_created)) / 60.0
  ) AS median_first_reply_min
FROM tickets t
JOIN first_outbound f ON f.ticket_id = t.id
GROUP BY 1
ORDER BY 1;

SELECT
  t.channel,
  COUNT(*)           AS tickets
FROM tickets t
WHERE t.date_created >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY t.channel
ORDER BY tickets DESC;

SELECT
  d.name             AS department,
  COUNT(*)           AS open_tickets
FROM tickets t
JOIN departments d ON d.id = t.department_id
WHERE t.status <> 'R'
GROUP BY d.name
ORDER BY open_tickets DESC;

What are common mistakes when analyzing LiveAgent in Metabase?

Related

Related analytics

Related integrations

FAQ