MCP.Market

Convai Analytics MCP server

by Conv-AI·io.github.Conv-AI/convai-analytics-mcp·v0.2.5
No reviews yet

Analyze Convai sessions, latency, reliability, usage, and provider telemetry via API key.

B74/100grade B
Write a reviewInstall
What users say
No reviews yet
Be the first
Safety scan
B74/100

full report

Adoption
New

0 stars35 downloads/wk

Reviews

Write one

Nobody has reviewed Convai Analytics yet.

If you have run it, two minutes of your experience saves the next person an afternoon.

Convai Analytics tools (44)

write = sends, deletes, buys or posts

Read from the package source without running it. The installed server may list more.

  • advanced_query

    Plan-gated. Run an advanced analytics query through the public API for questions not covered by curated tools.

  • compare_providers

    Compare provider or model latency for LLM, TTS, ASR, or NeuroSync components.

  • detect_regressions

    Plan-gated. Detect whether latency regressed in the current window compared with a baseline window.

  • estimate_active_session_concurrency

    Estimate active session and LiveKit room pressure from session start/end/duration telemetry.

  • explain_slow_session

    Find a traceable slow interaction in a session or slow-session list and return the session timeline, trace, top span, and waterfall chart.

  • find_component_latency_bottlenecks

    Rank the top latency offenders by component so an agent can explain likely bottlenecks.

  • generate_active_session_concurrency_chart

    Generate a Vega-Lite area chart estimating active sessions over time.

  • generate_character_usage_chart

    Generate a Vega-Lite leaderboard chart of sessions by character.

  • generate_component_latency_chart

    Generate a Vega-Lite bar chart showing p95 latency by processor/component.

  • generate_dropped_error_persist_chart

    Generate a Vega-Lite trend chart for dropped error-persistence events.

  • generate_error_breakdown_chart

    Generate a Vega-Lite bar chart of errors by processor/component.

  • generate_error_trend_chart

    Generate a Vega-Lite line chart showing errors over time.

  • generate_interaction_waterfall

    Generate a Vega-Lite waterfall chart for one interaction id's per-component latency breakdown.

  • generate_llm_model_latency_chart

    Generate a Vega-Lite chart ranking LLM models by p95 latency.

  • generate_peak_concurrency_chart

    Generate a Vega-Lite chart showing estimated active sessions with a peak concurrency annotation.

  • generate_reliability_summary_chart

    Generate a Vega-Lite chart of interactions, sessions, errors, and error rate for a time range.

  • generate_reliability_trends_chart

    Generate a Vega-Lite trend chart that combines errors and dropped persistence events.

  • generate_session_duration_scatter

    Generate a Vega-Lite scatter plot of session duration versus interactions, colored by p95 latency.

  • generate_tts_provider_chart

    Generate a Vega-Lite chart of TTS provider attribution.

  • generate_usage_trends_chart

    Generate a Vega-Lite chart for sessions, interactions, and unique end users over time.

  • get_character_usage_leaderboard

    Rank characters by session volume for the selected time range.

  • get_component_latency_breakdown

    Answer which processor/component is contributing most to p95 end-to-end latency.

  • get_dropped_error_persist_trend

    Track dropped error-persistence events over time as a reliability signal.

  • get_error_breakdown

    Break down errors by processor/component to identify reliability hotspots.

  • get_error_trend

    Answer whether errors are rising or falling over time.

  • get_first_response_breakdown

    Group first-response SLA P50/P95/P99 for one character by mode, settings_hash, stage, provider, model, status, or turn_scope.

  • get_first_response_markers

    Return settings-hash change markers for one character's first-response latency graph.

  • get_first_response_settings

    Fetch one sanitized latency-relevant settings snapshot by settings hash.

  • get_first_response_summary

    Character-first, mode-specific first-response SLA P50/P95/P99. Defaults include turn 1; use turnScope=warm for turn_id > 1.

  • get_first_response_timeseries

    Bucketed first-response SLA P50/P95/P99 for one character and optional observed mode.

  • get_interaction_first_response

    Return the additive first-response waterfall for one interaction id.

  • get_interaction_trace

    Show the per-request component spans for one interaction id, including processor/provider/model durations where available.

  • get_latency_heatmap_chart

    Generate a Vega-Lite heatmap of p95 latency by day and UTC hour to spot systemic slow windows.

  • get_latency_percentile_chart

    Generate a Vega-Lite line chart for aggregate P50/P95/P99 latency distribution over time for production readiness sign-off.

  • get_latency_percentile_series

    Fetch one raw P50/P95/P99 end-to-end latency timeseries for custom analysis or charting.

  • get_latency_threshold_chart

    Generate a Vega-Lite chart showing p95 latency against a production-readiness threshold.

  • get_llm_model_latency

    Rank LLM models by p95 latency to spot model-driven latency issues.

  • get_metrics_catalog

    List the public metrics this account can query so an agent can choose the right latency, reliability, usage, provider, or model metric.

  • get_p95_latency_over_time

    Answer whether p95 end-to-end voice latency is getting better or worse over time.

  • get_session_timeline

    Show the timeline of metrics and interaction ids inside one session, useful for explaining why a session felt slow.

  • get_summary

    Answer account-level questions like how many sessions, interactions, unique end users, errors, and headline latency percentiles happened in a time range.

  • get_tts_provider_attribution

    Show which TTS voice providers contributed samples in the selected time range.

  • get_usage_trends

    Fetch sessions, interactions, and unique end users over time for usage trend analysis.

  • list_sessions

    Find recent, longest, or slowest sessions for the caller's account before drilling into a session timeline or interaction trace.

Public scan report

scanner v0.1.9 · 2026-09-27 · same rubric, same numbers if you re-run it

no findings
  • Code scan16 source files scanned25/25
  • –Live reliabilityno gateway calls yet and no remote to proben/a
  • –Tool poisoningtools not inspected (local package is not executed); not countedn/a
  • Auth qualitystatic API keys via environment variables6/15
  • Maintenancelast push 132 days ago8/15
  • Maintainer identityregistry namespace matches repository owner; GitHub account older than a year9/10
Overall 74/100. Components that don't apply are left out of the denominator. Any critical finding is an F.RubricAppeal a findingJSON

How Convai Analytics compares

Against every graded MCP server, from our own scans and uptime checks. Updated after each scan run.

Safety score
74/100
higher than 40% of 48,255 servers
Tools
44
the typical server has 7
Tools that change things
0%
typical: 0%. Fewer write tools means less an agent can break
Downloads a week
35
more than 25% of 12,191 servers with a package

What its tools let an agent do: 30 read · 14 create

Install Convai Analytics in Claude Code, Cursor or VS Code

Runs npx -y @convai/analytics-mcp on your machine. Read the scan report first; the gateway never runs local packages.

claude mcp add convai-analytics-mcp -- npx -y @convai/analytics-mcp
Add to Cursor

What the publisher says

From the Convai Analytics repository's README, as published. We do not edit it. Read it on GitHub

convai-analytics

Agentic analytics for Convai applications.

This repository lets MCP-capable agents, coding agents, and developers answer questions about Convai session telemetry using only a Convai API key. The recommended path is the published local MCP server, @convai/analytics-mcp, which plugs into Claude Desktop, Cursor, Codex-compatible MCP clients, and other stdio MCP hosts so agents can call typed analytics tools instead of writing custom scripts.

For developers who want direct programmatic access, the repo also includes TypeScript, Python, and CLI clients that use the same public Analytics API.

Ask questions like:

How many interactions did my characters have in the last 7 days?

How many unique end users used each character this month?

Show aggregate P50/P95/P99 latency over time for production readiness sign-off.

Explain why this interaction was slow and generate a waterfall chart.

Which processor, provider, model, or character is driving latency or errors?

The SDK calls Convai's hosted analytics API at https://analytics-api.convai.com/v1/analytics. The API resolves your API key server-side, scopes every query to your account, enforces plan and quota limits, and returns agent-friendly JSON that can be summarized, charted, or used in scripts.

Status: v0.2. The full v1 endpoint surface is wired: summary, timeseries, breakdown, sessions.list, sessions.get, interactions.get, metrics/catalog, regression-detection, and query. Convenience facades (latency, providers, errors, usage) work end to end on top of those primitives.

What This Is

  • A local MCP server in packages/mcp that exposes the main analytics questions as typed agent tools.
  • A TypeScript SDK in packages/typescript.
  • A Python SDK in packages/python.
  • A CLI in cli.
  • Prompt recipes in recipes/prompts that tell an AI agent exactly which calls to make for common analytics questions.
  • Chart recipes in recipes/charts that generate Vega-Lite specs or Plotly timelines for latency, usage, reliability, and concurrency analysis.

What This Is Not

  • Not a client-side browser SDK. Your Convai API key is a bearer secret. Do not put it in browser JavaScript, mobile apps, public notebooks, screenshots, logs, or committed config files.
  • Not a direct data-store client. All reads go through Convai's hosted Analytics API with server-side account scoping, plan checks, and quota enforcement.
  • Not a write API. It only reads analytics data. It does not mutate characters, sessions, configs, or telemetry.
  • Not a replacement for the Convai dashboard. It is the programmable and agent-friendly surface for deeper analysis, automation, and chart generation.

Repository Layout

convai-analytics/
├── docs/                       Concepts, auth, metrics reference, prompt/chart indexes
├── openapi/                    Snapshot of the analytics API contract
├── packages/
│   ├── typescript/             @convai/analytics SDK
│   ├── mcp/                    @convai/analytics-mcp local stdio server
│   └── python/                 convai-analytics SDK
├── cli/                        convai-analytics command line interface
├── recipes/
│   ├── prompts/                Natural-language prompt templates for AI agents
│   └── charts/                 Runnable chart-generation scripts
└── examples/                   Runnable end-to-end examples

Prerequisites

  • Node.js 18+ for the TypeScript SDK, CLI, examples, and chart recipes.
  • Python 3.10+ and uv for the Python SDK examples.
  • A Convai API key for the account whose analytics you want to query.

Get your key from the same Convai account you use for the rest of the Convai API, then export it in your shell:

export CONVAI_API_KEY="ck_live_your_key_here"

Shortened. The full README is on GitHub.

Nothing above is checked by us. What we check is on the safety report.

Convai Analytics: common questions

Is Convai Analytics MCP server safe?
Mostly: it is graded B (74/100). Read the Convai Analytics safety report
How do I install Convai Analytics?
It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.
Does Convai Analytics need an API key?
Yes. The registry entry asks for CONVAI_API_KEY.
Is Convai Analytics maintained?
The last commit was 169 days ago (2026-05-19). The latest release is v0.2.5.
How does Convai Analytics compare with other MCP servers?
safety score 74/100 (higher than 40% of 48,255 servers); tools 44 (the typical server has 7); tools that change things 0% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.