Trodo MCP Server

Connect any MCP client to your Trodo data. Ask Claude, Cursor, or your own agent to query runs, issues, evals, funnels, and users in plain language.

Trodo runs a hosted Model Context Protocol server at https://mcp.trodo.ai/mcp. Point an MCP client at it and your assistant can read straight from your Trodo data: agent runs and traces, detected issues, evaluator results, product-analytics funnels and retention, use-case clusters, and (opt-in) user profiles. No SQL, no dashboard clicks. You ask, it queries.

It's read-first and discovery-driven. The server ships a catalog of tools the model calls on its own (list_event_names, list_agent_runs, get_issue_details, run_funnel_query, and ~70 more), so "which users hit the hallucination issue this week, and what were they trying to do?" becomes a few tool calls instead of an afternoon of filtering.

What you can do with it

Every tool is grouped into a capability bucket, and each bucket is gated by a scope on your key. At a high level:

Capability	What the assistant can do	Examples
Agent runs & traces	Inspect runs, span trees, latency, token cost, tool calls, and failure modes.	`list_agent_runs`, `get_agent_run`, `get_run_metrics`, `get_token_cost_breakdown`, `get_top_failure_modes`
Issues	Read detected issues, their root cause, timeline, affected users, and failing tools; change status.	`list_issues`, `get_issue_details`, `get_issue_members`, `set_issue_status`
Evaluations	Read evaluator results per run/span, manage evaluators, and work the human-review queue.	`list_evaluators`, `get_eval_results_for_run`, `create_evaluator`, `backfill_evaluator`, `submit_human_eval_grade`
Product analytics	Run funnels, retention, flows, insights, segment and period comparisons over your events.	`run_funnel_query`, `run_retention_query`, `run_flow_query`, `compare_periods`, `get_segment_comparison`
UX & technical health	Surface rage clicks, scroll depth, form abandonment, JS/network errors, and page performance.	`get_rage_click_analysis`, `get_form_abandonment_analysis`, `get_js_error_analysis`, `get_page_performance_analysis`
Use-case clusters	List what users are trying to do and pull the runs behind each cluster.	`list_use_case_clusters`, `get_cluster_runs`, `get_cluster_summary`
Users & groups (opt-in)	Look up a profile, reconstruct a journey, find users by email or wallet, list groups.	`get_user_profile`, `get_user_journey`, `find_users`, `list_groups`

The full tool set evolves as Trodo ships features, so the exact names above may shift. The server's tools/list is always the source of truth — most clients show it once connected, and the model reads it automatically.

Before you connect

Check your plan. MCP access requires a Growth or Enterprise plan. Free-plan keys are rejected with HTTP 402.

Generate a key. Go to app.trodo.ai/settings/integrations/mcp and create a key. It's shown once at creation (Trodo stores only a hash), so copy it then. Keys are prefixed trodo_mk_.

Pick the scopes the key should carry (for example agent runs + issues, but not user PII). See Scopes and permissions. You can issue several keys with different scopes; a team can hold up to 25.

Two ways to authenticate

Direct API key — a trodo_mk_ key sent as Authorization: Bearer …. Best for CLI and editor clients (Claude Code, Cursor, MCP Inspector, your own scripts). No browser flow.
OAuth — a browser consent flow. Used by clients that add a "custom connector" by URL, like Claude.ai web and Claude Desktop. You approve the connection once and the client manages the token.

Connect your client

Add it over HTTP with your key in the header (no wrapper needed):

claude mcp add trodo \
  --transport http \
  --url https://mcp.trodo.ai/mcp \
  --header "Authorization: Bearer trodo_mk_xxx"

Or use the stdio wrapper (trodomcp), which bridges stdio to the hosted server:

claude mcp add trodo \
  --transport stdio \
  --command "npx -y trodomcp" \
  --env TRODO_MCP_API_KEY=trodo_mk_xxx

Then just ask, for example "List the top failure modes across my agent runs in the last 7 days."

Edit ~/.cursor/mcp.json:

{
  "mcpServers": {
    "trodo": {
      "command": "npx",
      "args": ["-y", "trodomcp"],
      "env": { "TRODO_MCP_API_KEY": "trodo_mk_xxx" }
    }
  }
}

Reload Cursor and the Trodo tools appear in the MCP panel.

These use OAuth, not API keys. Add a custom connector with the URL:

https://mcp.trodo.ai/mcp

Complete the consent flow in your browser. Claude manages the token from there. No trodo_mk_ key needed.

Inspect the server's tools and try calls by hand:

TRODO_MCP_API_KEY=trodo_mk_xxx npx @modelcontextprotocol/inspector npx -y trodomcp

The server speaks JSON-RPC 2.0 over Streamable HTTP (MCP 2025-03-26). POST to the endpoint with a bearer key:

curl https://mcp.trodo.ai/mcp \
  -H "Authorization: Bearer trodo_mk_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": { "protocolVersion": "2025-03-26", "clientInfo": { "name": "my-client", "version": "1.0.0" } }
  }'

The initialize response returns an Mcp-Session-Id header. Echo it back on every later request so your tool calls stitch into one session (Trodo uses it to group calls into a single run for its own analytics). Call tools/list to enumerate tools, then tools/call to run them.

The `trodomcp` wrapper

Clients that only speak stdio use the published trodomcp package. It's a zero-dependency adapter (Node 18+): it reads JSON-RPC from stdin, forwards each message to https://mcp.trodo.ai/mcp with your bearer key, and tracks the session id for you. Run it with npx -y trodomcp (no install) or npm install -g trodomcp.

Variable	Default	Description
`TRODO_MCP_API_KEY`	(required)	Your `trodo_mk_` key.
`TRODO_MCP_URL`	`https://mcp.trodo.ai/mcp`	Override for staging.
`TRODO_MCP_TIMEOUT_MS`	`60000`	Per-request timeout.
`TRODO_MCP_DEBUG`	`0`	Set to `1` to log diagnostics to stderr.

Scopes and permissions

A key carries only the scopes you grant it, and each tool checks its scope before running. A call for a tool outside the key's scopes returns HTTP 403 naming the missing scope.

Scope	Unlocks	Notes
`mcp:events`	Product analytics, UX & technical-health tools, event catalog, report creation.
`mcp:agent_runs`	Agent runs, traces, run metrics, failure modes, run catalog.
`mcp:cluster`	Use-case clusters and the Issues tools (list, details, members, status, heal callback).
`mcp:evals`	Evaluator management, results, and the human-review queue.
`mcp:user:read_pii`	User profiles, journeys, lookup by email/wallet, and groups.	Off by default. This exposes personal data — grant it only when you need user lookups.

Limits and troubleshooting

Rate limit. API keys default to 600 calls/minute per key; OAuth connections are lower. HTTP 429 means you're over.
HTTP 401 — the key was revoked or expired. Issue a new one from Settings.
HTTP 402 — your team is on the Free plan. Upgrade to Growth or Enterprise.
HTTP 403 mentioning a scope — re-issue the key with the missing scope (e.g. mcp:user:read_pii for user lookups).
Tool calls land as separate sessions — your client isn't echoing the Mcp-Session-Id header. The trodomcp wrapper handles this for you; for custom clients, send it back on every request.

Issues — what the issue tools read from.
Evaluations — evaluators and results exposed over MCP.
Reports — boards the analytics tools can compose.
Product Analytics — the event data behind funnels and retention.

MCP

On this page