Skip to main content
Glama
Sign In
vexo-mcp

vexo-mcp

by kishanssg
OverviewSchemaSourceRelated ServersDiscussionsAdmin
TypeScript
Remote

Vexo MCP — Unofficial / Community

A Model Context Protocol server for the Vexo analytics Export API. Ask Claude (or any MCP client) questions about your mobile app's events — event vocabulary, aggregated counts, per-day timelines, sessions, and raw event streams — using your own Vexo login.

Unofficial / community project. Not affiliated with, sponsored by, or endorsed by Vexo. "Vexo" is a trademark of its respective owner and is used here only to describe the service this tool connects to.

What it does (and doesn't)

Vexo's Export API is a single paginated event endpoint — there is no server-side filtering or query language and a hard limit of 5 requests per minute per app. So this connector is deliberately a set of purpose-built aggregation tools, not a general "run any query" interface or a bulk CSV exporter. It downloads events for a date window and aggregates them locally.

Practical consequence: keep date windows tight. A couple of hours or days returns quickly; a busy week can be dozens of pages and take several minutes because of the rate limit. The server throttles itself to stay within Vexo's limit and backs off on 429.

Related MCP server: apps-mcp

Tools

Tool

Purpose

vexo_get_event_names

Top 50 event names in a window — schema discovery.

vexo_count_events

Event counts over a range, optionally grouped by a dimension (any metadata key or top-level field) with cohort + event-name filters.

vexo_event_timeline

Per-day counts of specified events, optionally grouped — find the day behavior changes.

vexo_get_sessions

Recent session summaries: duration, screen/event counts, last screen.

vexo_get_recent_events

The most recent raw events for one entity, with full metadata.

vexo_overview

Totals + top breakdowns (event type, route, OS, device, country, app version).

A dimension is any top-level event field (deviceId, country, deviceSystemName, appVersion, route, sessionId, deviceModel, city, type) or any metadata key (e.g. worker_id, user_id). Set a default dimension with the group_key config so you don't have to pass it every time.

Installation

Option 1 — Claude Desktop (one-click)

  1. Download vexo-mcp.mcpb from Releases.

  2. Open it with Claude Desktop (or Settings → Extensions → Install Extension…).

  3. Fill in your Vexo App ID, email, and password in the extension settings. The password is stored in your OS keychain.

Option 2 — Manual config (npx)

Add to your MCP client config (e.g. claude_desktop_config.json):

{
  "mcpServers": {
    "vexo": {
      "command": "npx",
      "args": ["-y", "@kishanssg/vexo-mcp"],
      "env": {
        "VEXO_APP_ID": "your-app-uuid",
        "VEXO_USER": "you@example.com",
        "VEXO_PASSWORD": "your-password",
        "VEXO_GROUP_KEY": "worker_id",
        "VEXO_API_BASE": "https://api.vexo.co",
        "VEXO_DEFAULT_LOOKBACK_DAYS": "30"
      }
    }
  }
}

VEXO_APP_ID, VEXO_USER, and VEXO_PASSWORD are required; the rest are optional.

Authentication

Vexo's Export API authenticates with email + password only — it exchanges them for a short-lived token via POST /users/implicit/login. Vexo does not issue export API keys, so there is no key-auth mode. (The SDK key embedded in an app for sending events is unrelated and won't work here.) Your credentials are used solely to obtain that token; they are never logged or bundled.

Example prompts

  • "Using vexo, list the top event names from 2026-06-01 to 2026-06-07."

  • "Compare worker_shift_feed_viewed counts for workers 54, 111, and 2716 over the last two weeks."

  • "Show a daily timeline of worker_shift_feed_viewed for worker 54 from 2026-05-01 to 2026-06-01 — when did it stop?"

  • "Give me the 20 most recent sessions for worker 54 and flag the short ones."

  • "Pull the last 10 raw events for worker 54."

Development

git clone https://github.com/kishanssg/vexo-mcp.git
cd vexo-mcp
npm install
npm run build       # compile TypeScript -> build/
npm test            # vitest unit tests (no credentials needed)
npm run inspector   # exercise tools with the MCP Inspector

Build the installable bundle:

npm run mcpb:build  # produces vexo-mcp.mcpb

Security

  • No secrets in the bundle. Credentials come only from your config / environment and (in Claude Desktop) live in your OS keychain.

  • Read-only. It only reads events via Vexo's Export API; it never writes.

Privacy Policy

This connector collects no data. It has no backend, telemetry, or analytics. Your Vexo credentials and queries go directly from your machine to the Vexo API you configure (default https://api.vexo.co); results return only to your MCP client. Credentials are stored solely in your OS keychain (or your own config) and are never transmitted to the author or any third party; event data exists only transiently in memory while a tool call is answered. Full policy: PRIVACY.md.

License

MIT — see LICENSE. Unofficial community project; not affiliated with Vexo.

Available Tools

6 tools
vexo_count_eventsA
Read-only

Aggregate event counts over a date range, optionally grouped by a dimension. The workhorse for cohort comparison. Ranges > 31 days are split & merged automatically (deduped by event id).

A "dimension" is any top-level field (deviceId, country, deviceSystemName, appVersion, route, sessionId, deviceModel, city, type) OR any metadata key (e.g. "worker_id", "user_id").

Inputs: start_date, end_date: ISO dates (end inclusive of the day). group_by: OPTIONAL dimension to group by, e.g. "worker_id". If omitted, the server's configured group key is used; if none, results are totaled by event_name only. filter_values: OPTIONAL list restricting group_by to these values, e.g. ["54","111","2716"] to compare a specific cohort. Max 200. filters: OPTIONAL extra key/value constraints, e.g. {"deviceSystemName":"iOS"}. event_names: OPTIONAL list to restrict which events are counted.

Returns: { window, group_by, rows:[{group?, event_name, count}], truncated, total_count? }. Sorted by group then count desc. Groups/events with zero matches are absent. On failure: { error }.

Inputs: start_date (required), end_date (required), group_by, filter_values, +2 more.

vexo_event_timelineA
Read-only

Per-day timeline of specific events. Use to detect cutover dates — the day a group STOPS (or starts) firing an event. event_names is REQUIRED to bound output. Counts are bucketed by calendar day (UTC). Ranges > 31 days auto-split.

Inputs: event_names: REQUIRED list, e.g. ["worker_shift_feed_viewed","screen_view"]. start_date, end_date: ISO dates (end inclusive). group_by: OPTIONAL dimension, e.g. "worker_id" (defaults to server group key). filter_values: OPTIONAL list restricting group_by to these values. Max 200. filters: OPTIONAL extra key/value constraints. granularity: only "day" is supported.

Returns: { window, granularity, group_by, rows:[{group?, date, event_name, count}], truncated, total_count? }. Sorted by group, date, event_name. Days with no events are absent (a gap == no activity). On failure: { error }.

Inputs: event_names (required), start_date (required), end_date (required), group_by, +3 more.

vexo_get_event_namesA
Read-only

Discover the event-name vocabulary in a date window (schema discovery). Scans ALL Vexo events in [start_date, end_date] and returns the top 50 event names by frequency. Use this FIRST when you don't know which event names exist. event_name = metadata.name if present, else the event's top-level "type".

Inputs: start_date: ISO date "YYYY-MM-DD" (or full ISO datetime), e.g. "2026-06-01". end_date: ISO date, e.g. "2026-06-07". MUST be <= 31 days after start_date (Vexo caps a single range at ~31 days). Date-only end is inclusive.

Returns: { window:{start,end,days}, total_events, distinct_event_names, event_names:[{event_name, count}, ... up to 50, desc] }. On failure: { error }.

Inputs: start_date (required), end_date (required).

vexo_get_recent_eventsA
Read-only

Forensic dive into one entity's most recent raw events (newest first). Use after the aggregate tools point you at a specific entity and you need to read the actual event stream — names, screens, sessions, payloads.

Scans the configured lookback window (default 30 days) unless start_date/ end_date are given. Identify the entity with the "filters" selector.

Inputs: filters: REQUIRED key/value selector identifying the entity, e.g. {"worker_id":"54"} or {"deviceId":"abc-123"}. n: number of most recent events. Default 10, max 50. start_date, end_date: OPTIONAL ISO dates to override the lookback window.

Returns: { filters, window, rows:[{timestamp, event_name, screen, session_id, metadata}], truncated, total_count? }. On failure: { error }.

Inputs: filters (required), n, start_date, end_date.

vexo_get_sessionsA
Read-only

Summarize the most recent app sessions, grouped by an entity. Use to tell a "bailed out" session (short, few screens) apart from an "event-poor" session (normal length but missing data events).

By default scans the configured lookback window (default 30 days) ending now; pass start_date/end_date to override. Groups events by sessionId, then returns the N most recent sessions per group value (most recent first).

Inputs: group_by: OPTIONAL entity dimension (defaults to server group key, else "deviceId"), e.g. "worker_id". filter_values: OPTIONAL list restricting group_by to these values. Max 200. filters: OPTIONAL extra key/value constraints. n_sessions_per_group: default 20, max 50. start_date, end_date: OPTIONAL ISO dates to override the lookback window.

Returns: { window, group_by, rows:[{group?, session_id, start, end, duration_s, screen_count, event_count, last_screen}], truncated, total_count? }. screen_count = # of screen_view events. On failure: { error }.

Inputs: group_by, filter_values, filters, n_sessions_per_group, +2 more.

vexo_overviewA
Read-only

High-level breakdown of activity in a date window. Good first call to understand an app's traffic. Scans all events in [start_date, end_date] (<= 31 days) and returns totals plus top breakdowns.

Inputs: start_date, end_date (ISO dates, end inclusive, <=31 days apart).

Returns: { window, total_events, unique_sessions, unique_devices, by_event_type:[{value,count}], top_routes:[...], by_os:[...], top_devices:[...], by_country:[...], by_app_version:[...] } (each top list capped at 15). On failure: { error }.

Inputs: start_date (required), end_date (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Deploy Server
    One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

    TDQS

    A4.6/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool targets a distinct analytical task: aggregate counting, per-day timelines, event name discovery, raw event inspection, session summaries, and top-level overview. No two tools have overlapping purposes.

    Naming Consistency5/5

    All tools follow the consistent 'vexo_verb_noun' pattern (e.g., count_events, event_timeline, get_event_names). No deviations or mixed conventions.

    Tool Count5/5

    With 6 tools, the server is well-scoped for Vexo event analytics: discovery, aggregates, timelines, raw events, sessions, and overview. Each tool earns its place without being excessive.

    Completeness4/5

    The tool set covers the full read-analytics workflow: discover event names, get overview, count events with grouping, per-day timelines, raw events by entity, and session summaries. Minor gap: no direct cohort comparison across dimensions, but count_events with group_by handles it effectively.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Resources

    Related MCP Connectors

    Related MCP Servers

    • xeve-mcp-server

      xeveio
      A
      license
      Not graded
      quality
      D
      maintenance
      MCP server for xeve.io that enables AI assistants to query personal analytics including productivity, coding, health, music, and GitHub activity.
      15 npm
      MIT

    • apps-mcp

      jammaru
      A
      license
      Not graded
      quality
      B
      maintenance
      Unofficial MCP server for the Apps API that enables managing customers, payments, plans, coupons, and Discord integration through natural language.
      48 npm
      2
      MIT

    • smolanalytics

      Arjun0606
      A
      license
      Not graded
      quality
      B
      maintenance
      MCP server that provides product and web analytics capabilities, allowing AI coding assistants to query funnels, retention, trends, feature flags, A/B tests, and more in natural language.
      4
      MIT

    • aptabase-mcp

      billylo1
      A
      license
      A
      quality
      F
      maintenance
      Unofficial MCP server that lets AI agents query Aptabase analytics using cookie-authenticated dashboard endpoints, providing tools for metrics, events, and sessions.
      17
      1
      MIT