_ registry / mcp streamable-http · checked 1h ago

vinktar

https://mcp.vinktar.com

Registry code: 35023ff4f304f128

api record

Vinktar holds a product's analytics events and its error tracking (issues, stack traces). Use it to answer questions about how the product is used and what is breaking.

Until the person signs in, the tools are listed but every call except `get_install_guide` asks for sign-in, which only the person can do. If a call fails that way, tell them where to connect Vinktar in the app you are running in, then carry on:

endpoint
https://mcp.vinktar.com/mcp
protocol
streamable-http ·2025-06-18
authentication
bearer
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is vinktar live?
Yes — it answered the hub's last check (checked 1h ago). It answered 98% of checks over the last 30 days.
Is vinktar free to use?
Partly — some of its tools are open, others need a key or payment.
What tools does vinktar have?
28 tools: create_board, create_watch, define_event, delete_board, delete_panel, get_setup_status, run_sql, set_project_notes, ….
Is vinktar safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
97.8%

90 days 98.1%· all time 98.1%

latency
316ms

last good check

priced tools
0

of 28 tools

_ answered our checks, 90 days 418 checks · signed record
  • down → live
  • degraded → down· timeout after 20000ms
  • live → degraded· timeout after 20000ms
  • degraded → live
  • live → degraded· timeout after 20000ms
_ what it is for
used for
  • query product analytics
  • track application errors
takes → gives
text → data
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

_ what it can do 28 tools
1 open14 auth-required 13 never probed 15 of 28 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • get_install_guide open 3h ago

    The step-by-step guide for setting Vinktar up in the app you are working in: which SDK fits the stack (with current versions), the recommended file layout and environment variables, defining the tracking plan as you add events, proving it with get_setup_status, and the handover telling the person where each variable goes. Call this first when asked to install, set up or audit Vinktar, and follow it. It ends with Vinktar's conventions (event and property naming, descriptions, how an event changes, releases and environments, identifying users and connecting the browser visit to the server); pass section "conventions" for those alone before adding or changing a track() call in an app that is already set up. It answers before sign-in too, and then starts with where the person signs in from each app. Setup call: never counted.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "section": {
          "enum": [
            "all",
            "conventions"
          ],
          "type": "string",
          "description": "\"conventions\" returns only the naming and tracking conventions. Default: the whole guide, which includes them."
        }
      },
      "additionalProperties": false
    }
    arguments 14 lines
  • get_issue auth-required 1h ago

    Everything needed to debug one error issue: what it is, its status and history, how often and for whom it happens in the window (by release, environment, browser, URL, tag), the latest occurrence's stack trace (source-mapped when available, each in-app frame linking to its file in the repository once the project's repository URL is set), breadcrumbs and request, and the product events that user sent in the 30 minutes before it.

    mcp-tool

    {
      "type": "object",
      "required": [
        "issueId"
      ],
      "properties": {
        "to": {
          "type": "string",
          "description": "Window end, ISO 8601. Default now."
        },
        "from": {
          "type": "string",
          "description": "Window start, ISO 8601 (e.g. \"2026-09-01\" or \"2026-09-01T12:00:00Z\")."
        },
        "last": {
          "type": "string",
          "pattern": "^\\d{1,4}[hdw]$",
          "description": "Relative window ending now, e.g. \"1h\", \"24h\", \"7d\", \"30d\", \"90d\". Default \"14d\". Ignored when `from` is given."
        },
        "issueId": {
          "type": "string",
          "maxLength": 512,
          "description": "The issue id (from list_issues) or its Vinktar URL, as a person would paste it."
        }
      },
      "additionalProperties": false
    }
    arguments 27 lines
  • query_trends auth-required 1h ago

    Metrics over time: event counts, unique users or sessions, the sum, average or p95 of a numeric property, optionally split by one breakdown and compared to the previous period. The workhorse for "how many / how much / is it growing" questions. interval "total" returns one de-duplicated number per series for the whole window.

    mcp-tool

    {
      "type": "object",
      "required": [
        "series"
      ],
      "properties": {
        "to": {
          "type": "string",
          "description": "Window end, ISO 8601. Default now."
        },
        "from": {
          "type": "string",
          "description": "Window start, ISO 8601 (e.g. \"2026-09-01\" or \"2026-09-01T12:00:00Z\")."
        },
        "last": {
          "type": "string",
          "pattern": "^\\d{1,4}[hdw]$",
          "description": "Relative window ending now, e.g. \"1h\", \"24h\", \"7d\", \"30d\", \"90d\". Default \"14d\". Ignored when `from` is given."
        },
        "series": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "aggregation"
            ],
            "properties": {
              "event": {
                "type": "string",
                "maxLength": 200,
                "description": "Event name; omit for all events."
              },
              "label": {
                "type": "string",
                "maxLength": 100
              },
              "filters": {
                "type": "object",
                "required": [
                  "combinator"
                ],
                "properties": {
                  "groups": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "combinator"
                      ],
                      "properties": {
                        "groups": {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "required": [
                              "combinator"
                            ],
                            "properties": {
                              "groups": {
                                "type": "array",
                                "maxItems": 0
                              },
                              "filters": {
                                "type": "array",
                                "items": {
                                  "type": "object",
                                  "required": [
                                    "property",
                                    "op"
                                  ],
                                  "properties": {
                                    "op": {
                                      "enum": [
                                        "eq",
                                        "neq",
                                        "in",
                                        "contains",
                                        "gt",
                                        "lt",
                                        "is_set"
                                      ],
                                      "type": "string"
                                    },
                                    "values": {
                                      "type": "array",
                                      "items": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "maxItems": 100
                                    },
                                    "property": {
                                      "type": "object",
                                      "required": [
                                        "scope",
                                        "key"
                                      ],
                                      "properties": {
                                        "key": {
                                          "type": "string",
                                          "maxLength": 1000
                                        },
                                        "scope": {
                                          "enum": [
                                            "event",
                                            "context",
                                            "session",
                                            "user"
                                          ],
                                          "type": "string"
                                        }
                                      },
                                      "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                      "additionalProperties": false
                                    }
                                  },
                                  "additionalProperties": false
                                },
                                "maxItems": 10
                              },
                              "combinator": {
                                "enum": [
                                  "AND",
                                  "OR"
                                ],
                                "type": "string"
                              }
                            },
                            "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                            "additionalProperties": false
                          },
                          "maxItems": 5
                        },
                        "filters": {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "required": [
                              "property",
                              "op"
                            ],
                            "properties": {
                              "op": {
                                "enum": [
                                  "eq",
                                  "neq",
                                  "in",
                                  "contains",
                                  "gt",
                                  "lt",
                                  "is_set"
                                ],
                                "type": "string"
                              },
                              "values": {
                                "type": "array",
                                "items": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "maxItems": 100
                              },
                              "property": {
                                "type": "object",
                                "required": [
                                  "scope",
                                  "key"
                                ],
                                "properties": {
                                  "key": {
                                    "type": "string",
                                    "maxLength": 1000
                                  },
                                  "scope": {
                                    "enum": [
                                      "event",
                                      "context",
                                      "session",
                                      "user"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                "additionalProperties": false
                              }
                            },
                            "additionalProperties": false
                          },
                          "maxItems": 10
                        },
                        "combinator": {
                          "enum": [
                            "AND",
                            "OR"
                          ],
                          "type": "string"
                        }
                      },
                      "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                      "additionalProperties": false
                    },
                    "maxItems": 5
                  },
                  "filters": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "property",
                        "op"
                      ],
                      "properties": {
                        "op": {
                          "enum": [
                            "eq",
                            "neq",
                            "in",
                            "contains",
                            "gt",
                            "lt",
                            "is_set"
                          ],
                          "type": "string"
                        },
                        "values": {
                          "type": "array",
                          "items": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "maxItems": 100
                        },
                        "property": {
                          "type": "object",
                          "required": [
                            "scope",
                            "key"
                          ],
                          "properties": {
                            "key": {
                              "type": "string",
                              "maxLength": 1000
                            },
                            "scope": {
                              "enum": [
                                "event",
                                "context",
                                "session",
                                "user"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                          "additionalProperties": false
                        }
                      },
                      "additionalProperties": false
                    },
                    "maxItems": 20
                  },
                  "combinator": {
                    "enum": [
                      "AND",
                      "OR"
                    ],
                    "type": "string"
                  }
                },
                "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                "additionalProperties": false
              },
              "property": {
                "type": "object",
                "required": [
                  "scope",
                  "key"
                ],
                "properties": {
                  "key": {
                    "type": "string",
                    "maxLength": 1000
                  },
                  "scope": {
                    "enum": [
                      "event",
                      "context",
                      "session",
                      "user"
                    ],
                    "type": "string"
                  }
                },
                "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                "additionalProperties": false
              },
              "aggregation": {
                "enum": [
                  "total",
                  "unique_users",
                  "unique_sessions",
                  "sum",
                  "avg",
                  "p95"
                ],
                "type": "string"
              }
            },
            "additionalProperties": false
          },
          "maxItems": 5,
          "minItems": 1,
          "description": "One to five metrics. Each: {event, aggregation, property?, filters?, label?}. `property` is required for sum, avg and p95."
        },
        "compare": {
          "type": "boolean",
          "description": "Also compute the previous period of equal length."
        },
        "filters": {
          "type": "object",
          "required": [
            "combinator"
          ],
          "properties": {
            "groups": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "combinator"
                ],
                "properties": {
                  "groups": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "combinator"
                      ],
                      "properties": {
                        "groups": {
                          "type": "array",
                          "maxItems": 0
                        },
                        "filters": {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "required": [
                              "property",
                              "op"
                            ],
                            "properties": {
                              "op": {
                                "enum": [
                                  "eq",
                                  "neq",
                                  "in",
                                  "contains",
                                  "gt",
                                  "lt",
                                  "is_set"
                                ],
                                "type": "string"
                              },
                              "values": {
                                "type": "array",
                                "items": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "maxItems": 100
                              },
                              "property": {
                                "type": "object",
                                "required": [
                                  "scope",
                                  "key"
                                ],
                                "properties": {
                                  "key": {
                                    "type": "string",
                                    "maxLength": 1000
                                  },
                                  "scope": {
                                    "enum": [
                                      "event",
                                      "context",
                                      "session",
                                      "user"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                "additionalProperties": false
                              }
                            },
                            "additionalProperties": false
                          },
                          "maxItems": 10
                        },
                        "combinator": {
                          "enum": [
                            "AND",
                            "OR"
                          ],
                          "type": "string"
                        }
                      },
                      "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                      "additionalProperties": false
                    },
                    "maxItems": 5
                  },
                  "filters": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "property",
                        "op"
                      ],
                      "properties": {
                        "op": {
                          "enum": [
                            "eq",
                            "neq",
                            "in",
                            "contains",
                            "gt",
                            "lt",
                            "is_set"
                          ],
                          "type": "string"
                        },
                        "values": {
                          "type": "array",
                          "items": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "maxItems": 100
                        },
                        "property": {
                          "type": "object",
                          "required": [
                            "scope",
                            "key"
                          ],
                          "properties": {
                            "key": {
                              "type": "string",
                              "maxLength": 1000
                            },
                            "scope": {
                              "enum": [
                                "event",
                                "context",
                                "session",
                                "user"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                          "additionalProperties": false
                        }
                      },
                      "additionalProperties": false
                    },
                    "maxItems": 10
                  },
                  "combinator": {
                    "enum": [
                      "AND",
                      "OR"
                    ],
                    "type": "string"
                  }
                },
                "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                "additionalProperties": false
              },
              "maxItems": 5
            },
            "filters": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "property",
                  "op"
                ],
                "properties": {
                  "op": {
                    "enum": [
                      "eq",
                      "neq",
                      "in",
                      "contains",
                      "gt",
                      "lt",
                      "is_set"
                    ],
                    "type": "string"
                  },
                  "values": {
                    "type": "array",
                    "items": {
                      "type": "string",
                      "maxLength": 1000
                    },
                    "maxItems": 100
                  },
                  "property": {
                    "type": "object",
                    "required": [
                      "scope",
                      "key"
                    ],
                    "properties": {
                      "key": {
                        "type": "string",
                        "maxLength": 1000
                      },
                      "scope": {
                        "enum": [
                          "event",
                          "context",
                          "session",
                          "user"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                    "additionalProperties": false
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 20
            },
            "combinator": {
              "enum": [
                "AND",
                "OR"
              ],
              "type": "string"
            }
          },
          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
          "additionalProperties": false
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "interval": {
          "enum": [
            "hour",
            "day",
            "week",
            "month",
            "total"
          ],
          "type": "string",
          "description": "Bucket size. Default chosen from the window (hour ≤2d, day ≤120d, week beyond)."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        },
        "breakdowns": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "scope",
              "key"
            ],
            "properties": {
              "key": {
                "type": "string",
                "maxLength": 1000
              },
              "scope": {
                "enum": [
                  "event",
                  "context",
                  "session",
                  "user"
                ],
                "type": "string"
              }
            },
            "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
            "additionalProperties": false
          },
          "maxItems": 1,
          "description": "Split every series by one property."
        }
      },
      "additionalProperties": false
    }
    arguments 613 lines
  • list_issues auth-required 7h ago

    Error-tracking issues (errors grouped by fingerprint) for a project, or across several with `projects`, with occurrences and affected users inside the window. Default: open issues (unresolved + regressed) sorted by occurrences over the last 14 days. Follow up with get_issue for the stack trace.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "to": {
          "type": "string",
          "description": "Window end, ISO 8601. Default now."
        },
        "from": {
          "type": "string",
          "description": "Window start, ISO 8601 (e.g. \"2026-09-01\" or \"2026-09-01T12:00:00Z\")."
        },
        "last": {
          "type": "string",
          "pattern": "^\\d{1,4}[hdw]$",
          "description": "Relative window ending now, e.g. \"1h\", \"24h\", \"7d\", \"30d\", \"90d\". Default \"14d\". Ignored when `from` is given."
        },
        "sort": {
          "enum": [
            "occurrences",
            "users",
            "last_seen",
            "first_seen"
          ],
          "type": "string",
          "description": "Default \"occurrences\"; \"first_seen\" surfaces new issues."
        },
        "level": {
          "type": "array",
          "items": {
            "enum": [
              "fatal",
              "error",
              "warning",
              "info"
            ],
            "type": "string"
          },
          "maxItems": 4
        },
        "limit": {
          "type": "integer",
          "maximum": 50,
          "minimum": 1,
          "description": "Default 20."
        },
        "cursor": {
          "type": "string",
          "maxLength": 256
        },
        "search": {
          "type": "string",
          "maxLength": 200,
          "description": "Matches title, error type or message."
        },
        "status": {
          "enum": [
            "open",
            "unresolved",
            "regressed",
            "resolved",
            "ignored",
            "all"
          ],
          "type": "string",
          "description": "Default \"open\"."
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "release": {
          "type": "string",
          "maxLength": 128
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        },
        "environment": {
          "type": "string",
          "maxLength": 64
        }
      },
      "additionalProperties": false
    }
    arguments 91 lines
  • list_projects auth-required 7h ago

    List the Vinktar projects this connection can read (a project is one app or site sending events and errors), with the workspace plan and what this connection is allowed to do. Call this first when you do not know the project handle.

    mcp-tool

    {
      "type": "object",
      "properties": {},
      "additionalProperties": false
    }
    arguments 5 lines
  • list_issue_occurrences auth-required 3d ago

    Recent individual occurrences of one issue, newest first: when, which user and session, release, environment, page, browser and OS. Use it to spot a pattern (one browser, one release, one customer) or to pick a user or session to follow in browse_events.

    mcp-tool

    {
      "type": "object",
      "required": [
        "issueId"
      ],
      "properties": {
        "limit": {
          "type": "integer",
          "maximum": 50,
          "minimum": 1,
          "description": "Default 15."
        },
        "cursor": {
          "type": "string",
          "maxLength": 256
        },
        "issueId": {
          "type": "string",
          "maxLength": 512,
          "description": "The issue id (from list_issues) or its Vinktar URL, as a person would paste it."
        }
      },
      "additionalProperties": false
    }
    arguments 24 lines
  • get_watch auth-required 35d ago

    Read watches and what they said. Pass watchId for one watch (a fix watch reports its state: awaiting_release, watching, recurred, no_recurrence, not_enough_evidence or stopped, with exposure and recurrences on the fix release); issueId for that issue's latest fix watch; or neither for every watch in the project and what fired in the last 24 hours. A watch is any standing question about the project: the error stream, an issue, a panel, a board or an event.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "issueId": {
          "type": "string",
          "maxLength": 512,
          "description": "The issue id (from list_issues) or its Vinktar URL, as a person would paste it."
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "watchId": {
          "type": "string",
          "pattern": "^\\d{1,19}$"
        }
      },
      "additionalProperties": false
    }
    arguments 20 lines
  • whats_changed auth-required 3h ago

    Start here. One project's window, or several pooled with `projects` (every row then names its project), compared with the one before it, across analytics and errors: traffic (events, active users, sessions), the events that rose, fell, appeared or stopped, error volume, new, regressed and fastest-growing issues, and the releases that shipped, and what the project's watches said. Each row names the tool to go deeper.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "last": {
          "enum": [
            "24h",
            "7d",
            "30d"
          ],
          "type": "string",
          "description": "Default \"7d\", compared with the 7 days before."
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        }
      },
      "additionalProperties": false
    }
    arguments 29 lines
  • query_retention auth-required 2d ago

    Cohort retention: users who did targetEvent in a period form a cohort, and the table shows what share of each cohort did returningEvent in each later period. Use it for "do people come back" and "did retention improve after the change".

    mcp-tool

    {
      "type": "object",
      "required": [
        "targetEvent",
        "returningEvent"
      ],
      "properties": {
        "to": {
          "type": "string",
          "description": "Window end, ISO 8601. Default now."
        },
        "from": {
          "type": "string",
          "description": "Window start, ISO 8601 (e.g. \"2026-09-01\" or \"2026-09-01T12:00:00Z\")."
        },
        "last": {
          "type": "string",
          "pattern": "^\\d{1,4}[hdw]$",
          "description": "Relative window ending now, e.g. \"1h\", \"24h\", \"7d\", \"30d\", \"90d\". Default \"14d\". Ignored when `from` is given."
        },
        "period": {
          "enum": [
            "day",
            "week",
            "month"
          ],
          "type": "string",
          "description": "Cohort granularity. Default \"week\"."
        },
        "filters": {
          "type": "object",
          "required": [
            "combinator"
          ],
          "properties": {
            "groups": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "combinator"
                ],
                "properties": {
                  "groups": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "combinator"
                      ],
                      "properties": {
                        "groups": {
                          "type": "array",
                          "maxItems": 0
                        },
                        "filters": {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "required": [
                              "property",
                              "op"
                            ],
                            "properties": {
                              "op": {
                                "enum": [
                                  "eq",
                                  "neq",
                                  "in",
                                  "contains",
                                  "gt",
                                  "lt",
                                  "is_set"
                                ],
                                "type": "string"
                              },
                              "values": {
                                "type": "array",
                                "items": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "maxItems": 100
                              },
                              "property": {
                                "type": "object",
                                "required": [
                                  "scope",
                                  "key"
                                ],
                                "properties": {
                                  "key": {
                                    "type": "string",
                                    "maxLength": 1000
                                  },
                                  "scope": {
                                    "enum": [
                                      "event",
                                      "context",
                                      "session",
                                      "user"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                "additionalProperties": false
                              }
                            },
                            "additionalProperties": false
                          },
                          "maxItems": 10
                        },
                        "combinator": {
                          "enum": [
                            "AND",
                            "OR"
                          ],
                          "type": "string"
                        }
                      },
                      "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                      "additionalProperties": false
                    },
                    "maxItems": 5
                  },
                  "filters": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "property",
                        "op"
                      ],
                      "properties": {
                        "op": {
                          "enum": [
                            "eq",
                            "neq",
                            "in",
                            "contains",
                            "gt",
                            "lt",
                            "is_set"
                          ],
                          "type": "string"
                        },
                        "values": {
                          "type": "array",
                          "items": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "maxItems": 100
                        },
                        "property": {
                          "type": "object",
                          "required": [
                            "scope",
                            "key"
                          ],
                          "properties": {
                            "key": {
                              "type": "string",
                              "maxLength": 1000
                            },
                            "scope": {
                              "enum": [
                                "event",
                                "context",
                                "session",
                                "user"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                          "additionalProperties": false
                        }
                      },
                      "additionalProperties": false
                    },
                    "maxItems": 10
                  },
                  "combinator": {
                    "enum": [
                      "AND",
                      "OR"
                    ],
                    "type": "string"
                  }
                },
                "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                "additionalProperties": false
              },
              "maxItems": 5
            },
            "filters": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "property",
                  "op"
                ],
                "properties": {
                  "op": {
                    "enum": [
                      "eq",
                      "neq",
                      "in",
                      "contains",
                      "gt",
                      "lt",
                      "is_set"
                    ],
                    "type": "string"
                  },
                  "values": {
                    "type": "array",
                    "items": {
                      "type": "string",
                      "maxLength": 1000
                    },
                    "maxItems": 100
                  },
                  "property": {
                    "type": "object",
                    "required": [
                      "scope",
                      "key"
                    ],
                    "properties": {
                      "key": {
                        "type": "string",
                        "maxLength": 1000
                      },
                      "scope": {
                        "enum": [
                          "event",
                          "context",
                          "session",
                          "user"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                    "additionalProperties": false
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 20
            },
            "combinator": {
              "enum": [
                "AND",
                "OR"
              ],
              "type": "string"
            }
          },
          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
          "additionalProperties": false
        },
        "periods": {
          "type": "integer",
          "maximum": 12,
          "minimum": 2,
          "description": "Periods each cohort is tracked for. Default 8."
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        },
        "targetEvent": {
          "type": "string",
          "maxLength": 200,
          "description": "The event that puts a user in a cohort (e.g. \"signup\")."
        },
        "returningEvent": {
          "type": "string",
          "maxLength": 200,
          "description": "The event that counts as coming back (e.g. \"session_start\")."
        }
      },
      "additionalProperties": false
    }
    arguments 299 lines
  • list_boards auth-required 7h ago

    The boards whose panels read from a project, or from any of several with `projects`. A board shows what the team already decided matters; read one with get_board.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        }
      },
      "additionalProperties": false
    }
    arguments 20 lines
  • browse_events auth-required 3h ago

    Raw events, newest first, under simple filters: event names, one user (distinctId), page search, property filters or a VinktarQL WHERE expression. Use it to see what one user did, or to inspect real payloads. Pass `eventId` instead to get that one event in full, every column and the whole payload. Windows longer than 30 days are narrowed to their last 30. For counts, use query_trends or run_sql instead of paging.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "to": {
          "type": "string",
          "description": "Window end, ISO 8601. Default now."
        },
        "from": {
          "type": "string",
          "description": "Window start, ISO 8601 (e.g. \"2026-09-01\" or \"2026-09-01T12:00:00Z\")."
        },
        "last": {
          "type": "string",
          "pattern": "^\\d{1,4}[hdw]$",
          "description": "Relative window ending now, e.g. \"1h\", \"24h\", \"7d\", \"30d\", \"90d\". Default \"14d\". Ignored when `from` is given."
        },
        "limit": {
          "type": "integer",
          "maximum": 100,
          "minimum": 1,
          "description": "Default 25."
        },
        "names": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200
          },
          "maxItems": 50,
          "description": "Only these event names."
        },
        "cursor": {
          "type": "string",
          "maxLength": 256
        },
        "search": {
          "type": "string",
          "maxLength": 256,
          "description": "Case-insensitive substring of page_path or page_url."
        },
        "eventId": {
          "type": "string",
          "pattern": "^[0-9a-fA-F-]{32,36}$",
          "description": "One event in full, by the event_id a listing or run_sql returned. Every other argument is ignored."
        },
        "filters": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "key",
              "op",
              "value"
            ],
            "properties": {
              "op": {
                "enum": [
                  "EQ",
                  "NEQ",
                  "CONTAINS",
                  "NOT_CONTAINS",
                  "GT",
                  "LT",
                  "GTE",
                  "LTE"
                ],
                "type": "string"
              },
              "key": {
                "type": "string",
                "maxLength": 200
              },
              "value": {
                "type": "string",
                "maxLength": 1000
              }
            },
            "additionalProperties": false
          },
          "maxItems": 20,
          "description": "Each {key, op, value}: key is a column (country, page_path, release…) or \"properties.<key>\"; op EQ, NEQ, CONTAINS, NOT_CONTAINS, GT, LT, GTE, LTE."
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        },
        "distinctId": {
          "type": "string",
          "maxLength": 256,
          "description": "One person: matches user_id, distinct_id or device_id exactly."
        },
        "expression": {
          "type": "string",
          "maxLength": 2000,
          "description": "A VinktarQL boolean expression, e.g. \"properties.plan = 'pro' AND country = 'DE'\"."
        }
      },
      "additionalProperties": false
    }
    arguments 109 lines
  • get_schema auth-required 3d ago

    What a project tracks (or several, with `projects`, each under its own heading): event names with their volume over the last 30 days, the payload properties each event carries, user trait keys, and the columns and functions VinktarQL (run_sql) accepts. Call before any query so names are real. Pass `event` to see every property of one event, or `propertyKey` to see that property's most common values, which is how you find the exact spelling of one before filtering on it.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "event": {
          "type": "string",
          "maxLength": 200,
          "description": "Show only this event, with all of its property keys."
        },
        "limit": {
          "type": "integer",
          "maximum": 100,
          "minimum": 1,
          "description": "With `propertyKey`: how many values, default 30."
        },
        "search": {
          "type": "string",
          "maxLength": 200,
          "description": "With `propertyKey`: a case-insensitive substring to narrow the values."
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        },
        "propertyKey": {
          "type": "string",
          "maxLength": 200,
          "description": "Instead of the schema: the most frequent values of this property over the last 90 days, most common first. E.g. \"plan\" (scope event), \"country\" (scope context), \"company\" (scope user)."
        },
        "propertyScope": {
          "enum": [
            "event",
            "context",
            "user"
          ],
          "type": "string",
          "description": "Where `propertyKey` lives. Default \"event\" (a payload property)."
        }
      },
      "additionalProperties": false
    }
    arguments 50 lines
  • get_project_keys auth-required 1h ago

    The keys installing Vinktar needs: the project's public write key (VINKTAR_KEY) with the ingest host, the Sentry-compatible DSN and the Bugsnag-compatible endpoints, and whether a source-map upload key (VINKTAR_CLI_KEY, a secret) exists, with where a person creates one. The secret is never returned: tell the person to add it as a CI secret. Needs a read and write connection. Setup call: never counted.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        }
      },
      "additionalProperties": false
    }
    arguments 11 lines
  • get_board auth-required 2d ago

    Read a board: every panel computed over a window with the change against the previous period, as headline numbers. The quickest way to answer "how are we doing" in the terms the team already tracks. Each panel shows its id, for update_panel and delete_panel.

    mcp-tool

    {
      "type": "object",
      "required": [
        "dashboardId"
      ],
      "properties": {
        "to": {
          "type": "string",
          "description": "Window end, ISO 8601. Default now."
        },
        "from": {
          "type": "string",
          "description": "Window start, ISO 8601 (e.g. \"2026-09-01\" or \"2026-09-01T12:00:00Z\")."
        },
        "last": {
          "type": "string",
          "pattern": "^\\d{1,4}[hdw]$",
          "description": "Relative window ending now, e.g. \"1h\", \"24h\", \"7d\", \"30d\", \"90d\". Default \"14d\". Ignored when `from` is given."
        },
        "dashboardId": {
          "type": "string",
          "pattern": "^\\d{1,19}$",
          "description": "From list_boards."
        }
      },
      "additionalProperties": false
    }
    arguments 27 lines
  • query_funnel auth-required 2d ago

    Conversion through an ordered sequence of events (e.g. view_pricing → start_checkout → purchase): how many entered, how many reached each step, where they dropped, how long converting took, optionally by segment.

    mcp-tool

    {
      "type": "object",
      "required": [
        "steps"
      ],
      "properties": {
        "to": {
          "type": "string",
          "description": "Window end, ISO 8601. Default now."
        },
        "from": {
          "type": "string",
          "description": "Window start, ISO 8601 (e.g. \"2026-09-01\" or \"2026-09-01T12:00:00Z\")."
        },
        "last": {
          "type": "string",
          "pattern": "^\\d{1,4}[hdw]$",
          "description": "Relative window ending now, e.g. \"1h\", \"24h\", \"7d\", \"30d\", \"90d\". Default \"14d\". Ignored when `from` is given."
        },
        "order": {
          "enum": [
            "ordered",
            "strict",
            "any"
          ],
          "type": "string",
          "description": "\"ordered\" (default): steps in sequence, other events allowed between; \"strict\": nothing between; \"any\": any order."
        },
        "steps": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "event"
            ],
            "properties": {
              "event": {
                "type": "string",
                "maxLength": 200
              },
              "label": {
                "type": "string",
                "maxLength": 100
              },
              "filters": {
                "type": "object",
                "required": [
                  "combinator"
                ],
                "properties": {
                  "groups": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "combinator"
                      ],
                      "properties": {
                        "groups": {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "required": [
                              "combinator"
                            ],
                            "properties": {
                              "groups": {
                                "type": "array",
                                "maxItems": 0
                              },
                              "filters": {
                                "type": "array",
                                "items": {
                                  "type": "object",
                                  "required": [
                                    "property",
                                    "op"
                                  ],
                                  "properties": {
                                    "op": {
                                      "enum": [
                                        "eq",
                                        "neq",
                                        "in",
                                        "contains",
                                        "gt",
                                        "lt",
                                        "is_set"
                                      ],
                                      "type": "string"
                                    },
                                    "values": {
                                      "type": "array",
                                      "items": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "maxItems": 100
                                    },
                                    "property": {
                                      "type": "object",
                                      "required": [
                                        "scope",
                                        "key"
                                      ],
                                      "properties": {
                                        "key": {
                                          "type": "string",
                                          "maxLength": 1000
                                        },
                                        "scope": {
                                          "enum": [
                                            "event",
                                            "context",
                                            "session",
                                            "user"
                                          ],
                                          "type": "string"
                                        }
                                      },
                                      "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                      "additionalProperties": false
                                    }
                                  },
                                  "additionalProperties": false
                                },
                                "maxItems": 10
                              },
                              "combinator": {
                                "enum": [
                                  "AND",
                                  "OR"
                                ],
                                "type": "string"
                              }
                            },
                            "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                            "additionalProperties": false
                          },
                          "maxItems": 5
                        },
                        "filters": {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "required": [
                              "property",
                              "op"
                            ],
                            "properties": {
                              "op": {
                                "enum": [
                                  "eq",
                                  "neq",
                                  "in",
                                  "contains",
                                  "gt",
                                  "lt",
                                  "is_set"
                                ],
                                "type": "string"
                              },
                              "values": {
                                "type": "array",
                                "items": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "maxItems": 100
                              },
                              "property": {
                                "type": "object",
                                "required": [
                                  "scope",
                                  "key"
                                ],
                                "properties": {
                                  "key": {
                                    "type": "string",
                                    "maxLength": 1000
                                  },
                                  "scope": {
                                    "enum": [
                                      "event",
                                      "context",
                                      "session",
                                      "user"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                "additionalProperties": false
                              }
                            },
                            "additionalProperties": false
                          },
                          "maxItems": 10
                        },
                        "combinator": {
                          "enum": [
                            "AND",
                            "OR"
                          ],
                          "type": "string"
                        }
                      },
                      "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                      "additionalProperties": false
                    },
                    "maxItems": 5
                  },
                  "filters": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "property",
                        "op"
                      ],
                      "properties": {
                        "op": {
                          "enum": [
                            "eq",
                            "neq",
                            "in",
                            "contains",
                            "gt",
                            "lt",
                            "is_set"
                          ],
                          "type": "string"
                        },
                        "values": {
                          "type": "array",
                          "items": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "maxItems": 100
                        },
                        "property": {
                          "type": "object",
                          "required": [
                            "scope",
                            "key"
                          ],
                          "properties": {
                            "key": {
                              "type": "string",
                              "maxLength": 1000
                            },
                            "scope": {
                              "enum": [
                                "event",
                                "context",
                                "session",
                                "user"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                          "additionalProperties": false
                        }
                      },
                      "additionalProperties": false
                    },
                    "maxItems": 20
                  },
                  "combinator": {
                    "enum": [
                      "AND",
                      "OR"
                    ],
                    "type": "string"
                  }
                },
                "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                "additionalProperties": false
              }
            },
            "additionalProperties": false
          },
          "maxItems": 10,
          "minItems": 2,
          "description": "Ordered steps: {event, label?, filters?}."
        },
        "filters": {
          "type": "object",
          "required": [
            "combinator"
          ],
          "properties": {
            "groups": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "combinator"
                ],
                "properties": {
                  "groups": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "combinator"
                      ],
                      "properties": {
                        "groups": {
                          "type": "array",
                          "maxItems": 0
                        },
                        "filters": {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "required": [
                              "property",
                              "op"
                            ],
                            "properties": {
                              "op": {
                                "enum": [
                                  "eq",
                                  "neq",
                                  "in",
                                  "contains",
                                  "gt",
                                  "lt",
                                  "is_set"
                                ],
                                "type": "string"
                              },
                              "values": {
                                "type": "array",
                                "items": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "maxItems": 100
                              },
                              "property": {
                                "type": "object",
                                "required": [
                                  "scope",
                                  "key"
                                ],
                                "properties": {
                                  "key": {
                                    "type": "string",
                                    "maxLength": 1000
                                  },
                                  "scope": {
                                    "enum": [
                                      "event",
                                      "context",
                                      "session",
                                      "user"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                "additionalProperties": false
                              }
                            },
                            "additionalProperties": false
                          },
                          "maxItems": 10
                        },
                        "combinator": {
                          "enum": [
                            "AND",
                            "OR"
                          ],
                          "type": "string"
                        }
                      },
                      "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                      "additionalProperties": false
                    },
                    "maxItems": 5
                  },
                  "filters": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "property",
                        "op"
                      ],
                      "properties": {
                        "op": {
                          "enum": [
                            "eq",
                            "neq",
                            "in",
                            "contains",
                            "gt",
                            "lt",
                            "is_set"
                          ],
                          "type": "string"
                        },
                        "values": {
                          "type": "array",
                          "items": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "maxItems": 100
                        },
                        "property": {
                          "type": "object",
                          "required": [
                            "scope",
                            "key"
                          ],
                          "properties": {
                            "key": {
                              "type": "string",
                              "maxLength": 1000
                            },
                            "scope": {
                              "enum": [
                                "event",
                                "context",
                                "session",
                                "user"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                          "additionalProperties": false
                        }
                      },
                      "additionalProperties": false
                    },
                    "maxItems": 10
                  },
                  "combinator": {
                    "enum": [
                      "AND",
                      "OR"
                    ],
                    "type": "string"
                  }
                },
                "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                "additionalProperties": false
              },
              "maxItems": 5
            },
            "filters": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "property",
                  "op"
                ],
                "properties": {
                  "op": {
                    "enum": [
                      "eq",
                      "neq",
                      "in",
                      "contains",
                      "gt",
                      "lt",
                      "is_set"
                    ],
                    "type": "string"
                  },
                  "values": {
                    "type": "array",
                    "items": {
                      "type": "string",
                      "maxLength": 1000
                    },
                    "maxItems": 100
                  },
                  "property": {
                    "type": "object",
                    "required": [
                      "scope",
                      "key"
                    ],
                    "properties": {
                      "key": {
                        "type": "string",
                        "maxLength": 1000
                      },
                      "scope": {
                        "enum": [
                          "event",
                          "context",
                          "session",
                          "user"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                    "additionalProperties": false
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 20
            },
            "combinator": {
              "enum": [
                "AND",
                "OR"
              ],
              "type": "string"
            }
          },
          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
          "additionalProperties": false
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        },
        "breakdown": {
          "type": "object",
          "required": [
            "scope",
            "key"
          ],
          "properties": {
            "key": {
              "type": "string",
              "maxLength": 1000
            },
            "scope": {
              "enum": [
                "event",
                "context",
                "session",
                "user"
              ],
              "type": "string"
            }
          },
          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
          "additionalProperties": false
        },
        "conversionWindow": {
          "type": "object",
          "required": [
            "value",
            "unit"
          ],
          "properties": {
            "unit": {
              "enum": [
                "minute",
                "hour",
                "day",
                "week",
                "month"
              ],
              "type": "string"
            },
            "value": {
              "type": "integer",
              "maximum": 365,
              "minimum": 1
            }
          },
          "description": "How long an entrant has to finish, e.g. {value: 1, unit: \"day\"}. Default 1 day.",
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    }
    arguments 592 lines
  • create_board unknown never probed

    Create an empty board in the workspace, to leave the user a view of what you found; fill it with add_panel, where each panel says which projects it reads. Pass `expiresInDays` for a board built for one launch, so it deletes itself afterwards instead of staying forever. Only do this when the user asked for a board or agreed to one.

    mcp-tool

    {
      "type": "object",
      "required": [
        "name"
      ],
      "properties": {
        "name": {
          "type": "string",
          "maxLength": 120
        },
        "description": {
          "type": "string",
          "maxLength": 100,
          "description": "One sentence saying what the board is for, at most 100 characters. It is the line under the board's title; a person can edit it in Vinktar."
        },
        "expiresInDays": {
          "type": "integer",
          "maximum": 180,
          "minimum": 1,
          "description": "Delete the board this many days from today. Leave it out for a board that stays. A person can change or clear the date in Vinktar."
        }
      },
      "additionalProperties": false
    }
    arguments 24 lines
  • create_watch unknown never probed

    Watch something and tell the workspace's owners and admins when it happens. Subjects: issues (the whole error stream: new_issue, regression, spike, occurrences, users_affected), issue (one issue: regression, spike, occurrences, users_affected), panel (a board panel from get_board: threshold, change), board (every panel on a board: change), event (one event's count or unique users, no panel needed: threshold, change; "below 1 per hour" means it stopped arriving). The issues and event subjects watch the projects in `projects` (every project this connection reaches when left out); the others follow the issue, panel or board they name. For a fix, use watch_issue. You cannot give a watch a webhook, a Slack URL or an email list: sending a workspace's data somewhere new is a person's decision, and a person adds destinations in Vinktar. Only create a watch when the user asked for one.

    mcp-tool

    {
      "type": "object",
      "required": [
        "name"
      ],
      "properties": {
        "name": {
          "type": "string",
          "maxLength": 128,
          "description": "What it watches, as a person would say it: \"Signups dropping\", \"New issues in production\"."
        },
        "event": {
          "type": "string",
          "maxLength": 200,
          "description": "subject event: the event name, from get_schema."
        },
        "window": {
          "enum": [
            "hour",
            "day"
          ],
          "type": "string",
          "description": "threshold and change: the trailing window the value is computed over. Default \"hour\"."
        },
        "boardId": {
          "type": "string",
          "pattern": "^\\d{1,19}$",
          "description": "subject board: the board, from list_boards."
        },
        "issueId": {
          "type": "string",
          "maxLength": 512,
          "description": "The issue id (from list_issues) or its Vinktar URL, as a person would paste it."
        },
        "panelId": {
          "type": "string",
          "pattern": "^\\d{1,19}$",
          "description": "subject panel: the panel, from get_board."
        },
        "percent": {
          "type": "number",
          "maximum": 10000,
          "minimum": 1,
          "description": "change only: how far it has to move, in percent. Default 50."
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "subject": {
          "enum": [
            "issues",
            "issue",
            "panel",
            "board",
            "event"
          ],
          "type": "string",
          "description": "What is watched."
        },
        "minLevel": {
          "enum": [
            "fatal",
            "error",
            "warning",
            "info"
          ],
          "type": "string",
          "description": "Error subjects: the least severe level that counts."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        },
        "condition": {
          "enum": [
            "new_issue",
            "regression",
            "spike",
            "occurrences",
            "users_affected",
            "threshold",
            "change"
          ],
          "type": "string",
          "description": "What counts as news: new_issue, regression, spike (against the 7-day baseline), occurrences (more than spikeMinCount in spikeWindowMinutes), users_affected (more than spikeMinCount distinct users in spikeWindowMinutes) for error subjects; threshold (crosses a line), change (moves by a percentage against the window before)."
        },
        "direction": {
          "enum": [
            "above",
            "below",
            "up",
            "down",
            "either"
          ],
          "type": "string",
          "description": "threshold: above (default) or below the line. change: up, down or either (default)."
        },
        "threshold": {
          "type": "number",
          "description": "threshold only: the line."
        },
        "aggregation": {
          "enum": [
            "total",
            "unique_users"
          ],
          "type": "string",
          "description": "subject event: count every event (default) or the people doing it."
        },
        "environment": {
          "type": "string",
          "maxLength": 64,
          "description": "Error subjects: only this environment, e.g. \"production\". Omit for all."
        },
        "spikeMinCount": {
          "type": "integer",
          "maximum": 100000,
          "minimum": 1,
          "description": "spike: a floor, so a quiet issue going from 1 to 4 is not a spike (default 50). occurrences, users_affected: the line (default 100)."
        },
        "spikeMultiplier": {
          "type": "number",
          "maximum": 100,
          "minimum": 1.5,
          "description": "spike only: how many times the baseline counts as a spike. Default 3."
        },
        "spikeWindowMinutes": {
          "type": "integer",
          "maximum": 1440,
          "minimum": 5,
          "description": "spike, occurrences, users_affected: the window in minutes. Default 10 for spike, 60 otherwise."
        }
      },
      "additionalProperties": false
    }
    arguments 142 lines
  • define_event unknown never probed

    Define an event in the project's tracking plan: what it means, its role, the properties it carries (type, unit, whether every send must include it, an example) and where the code sends it. Call it in the same step as adding or changing a track() call, before any data arrives; and for existing events once you have read the code that sends them. It takes effect at once, labelled as written by an agent, and the team can correct it in Vinktar. get_setup_status then reports defined events that never arrive and sends missing a required property. Conventions (get_install_guide with section "conventions" has them all): new event names and property keys are snake_case, object then past-tense action (signed_up, report_exported); a description is one sentence of at most 100 characters and a longer one is refused; an event already shipping under another spelling is defined as it is sent, never renamed unasked. Do not overwrite a description the team wrote unless the user asks. Setup call: never counted.

    mcp-tool

    {
      "type": "object",
      "required": [
        "event"
      ],
      "properties": {
        "role": {
          "enum": [
            "signup",
            "activation",
            "conversion",
            "revenue",
            "none"
          ],
          "type": "string",
          "description": "The business moment it stands for, if any: signup, activation, conversion, revenue. \"none\" clears it."
        },
        "event": {
          "type": "string",
          "maxLength": 200,
          "description": "The name exactly as the code sends it. For an event you are adding: snake_case, object then past-tense action, like report_exported."
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "properties": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "key"
            ],
            "properties": {
              "key": {
                "type": "string",
                "maxLength": 200,
                "description": "As the code sends it; snake_case for a key you are adding."
              },
              "type": {
                "enum": [
                  "string",
                  "number",
                  "boolean",
                  "datetime",
                  "id",
                  "url",
                  "email",
                  "currency"
                ],
                "type": "string"
              },
              "unit": {
                "type": "string",
                "maxLength": 16,
                "description": "e.g. \"USD\", \"ms\"."
              },
              "example": {
                "type": "string",
                "maxLength": 200,
                "description": "A typical value, never a real person's data."
              },
              "required": {
                "type": "boolean",
                "description": "Every send of this event includes it."
              },
              "description": {
                "type": "string",
                "maxLength": 2000,
                "description": "One sentence, at most 100 characters."
              }
            },
            "additionalProperties": false
          },
          "maxItems": 30
        },
        "description": {
          "type": "string",
          "maxLength": 2000,
          "description": "What happened and when it fires: one sentence, at most 100 characters. Longer is refused."
        },
        "code_location": {
          "type": "string",
          "maxLength": 300,
          "description": "Where the code sends it, as a repo path and line: \"src/checkout/pay.ts:88\"."
        }
      },
      "additionalProperties": false
    }
    arguments 90 lines
  • delete_board unknown never probed

    Delete a board with its panels. Only when the user asked for it, or agreed when you proposed it; name the board before you do. A person can restore it in Vinktar from the boards page for 30 days.

    mcp-tool

    {
      "type": "object",
      "required": [
        "dashboardId"
      ],
      "properties": {
        "dashboardId": {
          "type": "string",
          "pattern": "^\\d{1,19}$",
          "description": "The board, from list_boards."
        }
      },
      "additionalProperties": false
    }
    arguments 14 lines
  • delete_panel unknown never probed

    Remove a panel from its board. Only when the user asked for it, or agreed when you proposed it; say which panel before you do. The panel id is in get_board. A person can restore it in Vinktar from the boards page for 30 days.

    mcp-tool

    {
      "type": "object",
      "required": [
        "panelId"
      ],
      "properties": {
        "panelId": {
          "type": "string",
          "pattern": "^\\d{1,19}$",
          "description": "The panel, from get_board."
        }
      },
      "additionalProperties": false
    }
    arguments 14 lines
  • get_setup_status unknown never probed

    Check a project's Vinktar install from the data that actually arrived: events and errors received, users identified, releases and environments tagged, source maps for the latest release, items the SDK dropped, and key events described. Each gap comes with the next step. Call it after installing, and again after each fix, until nothing is left to do. Setup call: never counted against the agent allowance.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        }
      },
      "additionalProperties": false
    }
    arguments 11 lines
  • run_sql unknown never probed

    Run a read-only VinktarQL SELECT over the project's `events` table, for anything query_trends, query_funnel and query_retention cannot express; start with those, since what they run is what a board panel should be. A ClickHouse-flavoured subset: WHERE, GROUP BY, HAVING, ORDER BY, LIMIT, DISTINCT, IN, LIKE and allowlisted functions (count, uniq, sum, avg, quantile, countIf, toStartOfDay…); no joins, subqueries, CTEs or INTERVAL, so filter time as `timestamp > now() - 86400 * 7`. Payload properties are `properties.<key>`, user traits `user.<key>`. Tenant scoping and plan retention are applied automatically. Call get_schema first for columns, functions and property names, and aggregate in SQL rather than paging through raw rows.

    mcp-tool

    {
      "type": "object",
      "required": [
        "query"
      ],
      "properties": {
        "limit": {
          "type": "integer",
          "maximum": 500,
          "minimum": 1,
          "description": "Rows per page, default 100."
        },
        "query": {
          "type": "string",
          "maxLength": 4096,
          "description": "One SELECT statement over `events`."
        },
        "cursor": {
          "type": "string",
          "maxLength": 64,
          "description": "The cursor from a previous page, to continue."
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "Project handles (as in list_projects) or ids, to read across several apps. Leave out for every project this connection can reach. For one project use `project`; never pass both."
        }
      },
      "additionalProperties": false
    }
    arguments 39 lines
  • set_project_notes unknown never probed

    Write the project's notes for AI agents: what the product does and for whom, the flows that matter (signup, activation, the paid action), what counts as an active user, and anything that makes the data easy to misread. Write them from the codebase during setup, in plain sentences, up to 2,000 characters; they replace the current notes, so read them in get_schema first and keep what the team wrote. Every later agent reads them before the data. Setup call: never counted.

    mcp-tool

    {
      "type": "object",
      "required": [
        "notes"
      ],
      "properties": {
        "notes": {
          "type": "string",
          "maxLength": 2000
        },
        "project": {
          "type": "string",
          "maxLength": 128,
          "description": "Project handle (as in list_projects) or id. Optional when this connection is limited to one project or the workspace has only one."
        }
      },
      "additionalProperties": false
    }
    arguments 18 lines
  • update_board unknown never probed

    Rename a board, rewrite the line under its title, change when it deletes itself, or lay its panels out. A board is a grid: every row spans the full width, its panels share it equally (one to four) at one height. Pass `rows` to set the layout outright, top to bottom, as rows of panel ids from get_board; panels you leave out keep their order after them. Or pass `arrange` to straighten the rows as they read now. Pass only what changes. Panels are changed with update_panel and delete_panel.

    mcp-tool

    {
      "type": "object",
      "required": [
        "dashboardId"
      ],
      "properties": {
        "name": {
          "type": "string",
          "maxLength": 120,
          "minLength": 1
        },
        "rows": {
          "type": "array",
          "items": {
            "type": "array",
            "items": {
              "type": "string",
              "pattern": "^\\d{1,19}$"
            },
            "maxItems": 4,
            "minItems": 1
          },
          "maxItems": 50,
          "minItems": 1,
          "description": "The rows, top to bottom, e.g. [[\"12\",\"13\",\"14\",\"15\"],[\"16\",\"17\"],[\"18\"]]: numbers up to four to a row, charts two, a table or text on its own."
        },
        "arrange": {
          "type": "boolean",
          "description": "Straighten the rows in their current order: numbers together, charts in pairs, one height per row."
        },
        "dashboardId": {
          "type": "string",
          "pattern": "^\\d{1,19}$",
          "description": "The board, from list_boards."
        },
        "description": {
          "type": "string",
          "maxLength": 100,
          "description": "One sentence saying what the board is for, at most 100 characters. Empty clears it."
        },
        "expiresInDays": {
          "type": "integer",
          "maximum": 180,
          "minimum": 0,
          "description": "Delete the board this many days from today; 0 keeps it for good."
        }
      },
      "additionalProperties": false
    }
    arguments 49 lines
  • update_issue unknown never probed

    Change an error issue's status or assignee: resolve it (optionally in the release that ships the fix, or in the next release when it has not shipped yet, so a later occurrence reopens it as a regression), ignore it, reopen it, or assign it to a teammate. Only act on an issue when the user asked you to.

    mcp-tool

    {
      "type": "object",
      "required": [
        "issueId"
      ],
      "properties": {
        "status": {
          "enum": [
            "resolved",
            "ignored",
            "unresolved"
          ],
          "type": "string"
        },
        "issueId": {
          "type": "string",
          "maxLength": 512,
          "description": "The issue id (from list_issues) or its Vinktar URL, as a person would paste it."
        },
        "assignee": {
          "type": "string",
          "maxLength": 254,
          "description": "\"me\", a teammate's email, or \"none\" to unassign."
        },
        "environment": {
          "type": "string",
          "maxLength": 64,
          "description": "With status \"ignored\" or \"unresolved\": act in this environment only (ignore it in staging, keep it live in production)."
        },
        "resolvedInRelease": {
          "type": "string",
          "maxLength": 64,
          "description": "With status \"resolved\": the release the fix ships in. Default: the last release it was seen in."
        },
        "resolvedInNextRelease": {
          "type": "boolean",
          "description": "With status \"resolved\": the fix has not shipped yet. The issue pins whichever release is seen next and only an occurrence on that release reopens it."
        }
      },
      "additionalProperties": false
    }
    arguments 41 lines
  • update_panel unknown never probed

    Change a panel on a board: its title, how it draws, its number format or what it shows. Pass only what changes; the rest stays as it is. The panel id is in get_board. To turn it into another type, pass `type` with the full spec for it, the same fields as add_panel. A changed panel is run and held to the same rules as add_panel before it is saved (structured types before SQL, one question per panel, the board's time range), and one that breaks them is refused with nothing changed.

    mcp-tool

    {
      "type": "object",
      "required": [
        "panelId"
      ],
      "properties": {
        "name": {
          "type": "string",
          "maxLength": 120,
          "description": "Panel title as the team will read it."
        },
        "text": {
          "type": "string",
          "maxLength": 2000,
          "description": "For type \"text\": the Markdown body. A heading for a row of panels, or a short note on how to read them. Your own words only: never paste captured data (error messages, payloads, URLs) into it."
        },
        "type": {
          "enum": [
            "funnel",
            "retention",
            "trends",
            "issues",
            "text",
            "sql"
          ],
          "type": "string",
          "description": "funnel, retention and trends first; sql only when they cannot express it."
        },
        "view": {
          "enum": [
            "steps",
            "timeToConvert",
            "trend",
            "bar",
            "table"
          ],
          "type": "string",
          "description": "Funnels only: steps (default, the drop-off per step), timeToConvert, trend (conversion rate over time), bar or table."
        },
        "chart": {
          "enum": [
            "line",
            "bar",
            "scalar",
            "table"
          ],
          "type": "string",
          "description": "For trends: line (default) over time, bar to compare segments, scalar for one number, table for rows. For retention: table (default, the cohort grid) or line (the average curve). For sql: table (default), line or bar."
        },
        "query": {
          "type": "string",
          "maxLength": 4096,
          "description": "For type \"sql\": the VinktarQL SELECT."
        },
        "funnel": {
          "type": "object",
          "required": [
            "steps"
          ],
          "properties": {
            "order": {
              "enum": [
                "ordered",
                "strict",
                "any"
              ],
              "type": "string",
              "description": "\"ordered\" (default): steps in sequence, other events allowed between; \"strict\": nothing between; \"any\": any order."
            },
            "steps": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "event"
                ],
                "properties": {
                  "event": {
                    "type": "string",
                    "maxLength": 200
                  },
                  "label": {
                    "type": "string",
                    "maxLength": 100
                  },
                  "filters": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "combinator"
                                ],
                                "properties": {
                                  "groups": {
                                    "type": "array",
                                    "maxItems": 0
                                  },
                                  "filters": {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "required": [
                                        "property",
                                        "op"
                                      ],
                                      "properties": {
                                        "op": {
                                          "enum": [
                                            "eq",
                                            "neq",
                                            "in",
                                            "contains",
                                            "gt",
                                            "lt",
                                            "is_set"
                                          ],
                                          "type": "string"
                                        },
                                        "values": {
                                          "type": "array",
                                          "items": {
                                            "type": "string",
                                            "maxLength": 1000
                                          },
                                          "maxItems": 100
                                        },
                                        "property": {
                                          "type": "object",
                                          "required": [
                                            "scope",
                                            "key"
                                          ],
                                          "properties": {
                                            "key": {
                                              "type": "string",
                                              "maxLength": 1000
                                            },
                                            "scope": {
                                              "enum": [
                                                "event",
                                                "context",
                                                "session",
                                                "user"
                                              ],
                                              "type": "string"
                                            }
                                          },
                                          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                          "additionalProperties": false
                                        }
                                      },
                                      "additionalProperties": false
                                    },
                                    "maxItems": 10
                                  },
                                  "combinator": {
                                    "enum": [
                                      "AND",
                                      "OR"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                                "additionalProperties": false
                              },
                              "maxItems": 5
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 20
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 10,
              "minItems": 2,
              "description": "Ordered steps: {event, label?, filters?}."
            },
            "filters": {
              "type": "object",
              "required": [
                "combinator"
              ],
              "properties": {
                "groups": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "maxItems": 0
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 10
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  },
                  "maxItems": 5
                },
                "filters": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "property",
                      "op"
                    ],
                    "properties": {
                      "op": {
                        "enum": [
                          "eq",
                          "neq",
                          "in",
                          "contains",
                          "gt",
                          "lt",
                          "is_set"
                        ],
                        "type": "string"
                      },
                      "values": {
                        "type": "array",
                        "items": {
                          "type": "string",
                          "maxLength": 1000
                        },
                        "maxItems": 100
                      },
                      "property": {
                        "type": "object",
                        "required": [
                          "scope",
                          "key"
                        ],
                        "properties": {
                          "key": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "scope": {
                            "enum": [
                              "event",
                              "context",
                              "session",
                              "user"
                            ],
                            "type": "string"
                          }
                        },
                        "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                        "additionalProperties": false
                      }
                    },
                    "additionalProperties": false
                  },
                  "maxItems": 20
                },
                "combinator": {
                  "enum": [
                    "AND",
                    "OR"
                  ],
                  "type": "string"
                }
              },
              "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
              "additionalProperties": false
            },
            "breakdown": {
              "type": "object",
              "required": [
                "scope",
                "key"
              ],
              "properties": {
                "key": {
                  "type": "string",
                  "maxLength": 1000
                },
                "scope": {
                  "enum": [
                    "event",
                    "context",
                    "session",
                    "user"
                  ],
                  "type": "string"
                }
              },
              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
              "additionalProperties": false
            },
            "conversionWindow": {
              "type": "object",
              "required": [
                "value",
                "unit"
              ],
              "properties": {
                "unit": {
                  "enum": [
                    "minute",
                    "hour",
                    "day",
                    "week",
                    "month"
                  ],
                  "type": "string"
                },
                "value": {
                  "type": "integer",
                  "maximum": 365,
                  "minimum": 1
                }
              },
              "description": "How long an entrant has to finish, e.g. {value: 1, unit: \"day\"}. Default 1 day.",
              "additionalProperties": false
            }
          },
          "additionalProperties": false
        },
        "issues": {
          "type": "object",
          "properties": {
            "sort": {
              "enum": [
                "occurrences",
                "users",
                "recent"
              ],
              "type": "string",
              "description": "Default \"occurrences\"."
            },
            "limit": {
              "type": "integer",
              "maximum": 10,
              "minimum": 1,
              "description": "Rows shown, default 5."
            },
            "environment": {
              "type": "string",
              "maxLength": 64,
              "description": "Only this environment, e.g. \"production\". Omit for all."
            }
          },
          "description": "For type \"issues\": the top error issues inside the board's window. Every field is optional.",
          "additionalProperties": false
        },
        "trends": {
          "type": "object",
          "required": [
            "series"
          ],
          "properties": {
            "series": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "aggregation"
                ],
                "properties": {
                  "event": {
                    "type": "string",
                    "maxLength": 200,
                    "description": "Event name; omit for all events."
                  },
                  "label": {
                    "type": "string",
                    "maxLength": 100
                  },
                  "filters": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "combinator"
                                ],
                                "properties": {
                                  "groups": {
                                    "type": "array",
                                    "maxItems": 0
                                  },
                                  "filters": {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "required": [
                                        "property",
                                        "op"
                                      ],
                                      "properties": {
                                        "op": {
                                          "enum": [
                                            "eq",
                                            "neq",
                                            "in",
                                            "contains",
                                            "gt",
                                            "lt",
                                            "is_set"
                                          ],
                                          "type": "string"
                                        },
                                        "values": {
                                          "type": "array",
                                          "items": {
                                            "type": "string",
                                            "maxLength": 1000
                                          },
                                          "maxItems": 100
                                        },
                                        "property": {
                                          "type": "object",
                                          "required": [
                                            "scope",
                                            "key"
                                          ],
                                          "properties": {
                                            "key": {
                                              "type": "string",
                                              "maxLength": 1000
                                            },
                                            "scope": {
                                              "enum": [
                                                "event",
                                                "context",
                                                "session",
                                                "user"
                                              ],
                                              "type": "string"
                                            }
                                          },
                                          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                          "additionalProperties": false
                                        }
                                      },
                                      "additionalProperties": false
                                    },
                                    "maxItems": 10
                                  },
                                  "combinator": {
                                    "enum": [
                                      "AND",
                                      "OR"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                                "additionalProperties": false
                              },
                              "maxItems": 5
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 20
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  },
                  "property": {
                    "type": "object",
                    "required": [
                      "scope",
                      "key"
                    ],
                    "properties": {
                      "key": {
                        "type": "string",
                        "maxLength": 1000
                      },
                      "scope": {
                        "enum": [
                          "event",
                          "context",
                          "session",
                          "user"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                    "additionalProperties": false
                  },
                  "aggregation": {
                    "enum": [
                      "total",
                      "unique_users",
                      "unique_sessions",
                      "sum",
                      "avg",
                      "p95"
                    ],
                    "type": "string"
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 5,
              "minItems": 1,
              "description": "One to five metrics. Each: {event, aggregation, property?, filters?, label?}. `property` is required for sum, avg and p95."
            },
            "filters": {
              "type": "object",
              "required": [
                "combinator"
              ],
              "properties": {
                "groups": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "maxItems": 0
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 10
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  },
                  "maxItems": 5
                },
                "filters": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "property",
                      "op"
                    ],
                    "properties": {
                      "op": {
                        "enum": [
                          "eq",
                          "neq",
                          "in",
                          "contains",
                          "gt",
                          "lt",
                          "is_set"
                        ],
                        "type": "string"
                      },
                      "values": {
                        "type": "array",
                        "items": {
                          "type": "string",
                          "maxLength": 1000
                        },
                        "maxItems": 100
                      },
                      "property": {
                        "type": "object",
                        "required": [
                          "scope",
                          "key"
                        ],
                        "properties": {
                          "key": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "scope": {
                            "enum": [
                              "event",
                              "context",
                              "session",
                              "user"
                            ],
                            "type": "string"
                          }
                        },
                        "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                        "additionalProperties": false
                      }
                    },
                    "additionalProperties": false
                  },
                  "maxItems": 20
                },
                "combinator": {
                  "enum": [
                    "AND",
                    "OR"
                  ],
                  "type": "string"
                }
              },
              "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
              "additionalProperties": false
            },
            "breakdowns": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "scope",
                  "key"
                ],
                "properties": {
                  "key": {
                    "type": "string",
                    "maxLength": 1000
                  },
                  "scope": {
                    "enum": [
                      "event",
                      "context",
                      "session",
                      "user"
                    ],
                    "type": "string"
                  }
                },
                "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                "additionalProperties": false
              },
              "maxItems": 1,
              "description": "Split every series by one property."
            }
          },
          "additionalProperties": false
        },
        "display": {
          "type": "object",
          "properties": {
            "format": {
              "enum": [
                "count",
                "currency",
                "percent"
              ],
              "type": "string",
              "description": "currency for money, percent for a rate; default count."
            },
            "legend": {
              "type": "boolean",
              "description": "Line charts: show the legend. Default true."
            },
            "stacked": {
              "type": "boolean",
              "description": "Bar charts with several series: stack them. Default true."
            }
          },
          "description": "For trends and sql.",
          "additionalProperties": false
        },
        "panelId": {
          "type": "string",
          "pattern": "^\\d{1,19}$",
          "description": "The panel, from get_board."
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "The projects this panel reads, by handle or id: a panel keeps its own set, so one board can hold panels over different apps. Leave out for every project this connection reaches."
        },
        "retention": {
          "type": "object",
          "required": [
            "targetEvent",
            "returningEvent"
          ],
          "properties": {
            "period": {
              "enum": [
                "day",
                "week",
                "month"
              ],
              "type": "string",
              "description": "Cohort granularity. Default \"week\"."
            },
            "filters": {
              "type": "object",
              "required": [
                "combinator"
              ],
              "properties": {
                "groups": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "maxItems": 0
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 10
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  },
                  "maxItems": 5
                },
                "filters": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "property",
                      "op"
                    ],
                    "properties": {
                      "op": {
                        "enum": [
                          "eq",
                          "neq",
                          "in",
                          "contains",
                          "gt",
                          "lt",
                          "is_set"
                        ],
                        "type": "string"
                      },
                      "values": {
                        "type": "array",
                        "items": {
                          "type": "string",
                          "maxLength": 1000
                        },
                        "maxItems": 100
                      },
                      "property": {
                        "type": "object",
                        "required": [
                          "scope",
                          "key"
                        ],
                        "properties": {
                          "key": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "scope": {
                            "enum": [
                              "event",
                              "context",
                              "session",
                              "user"
                            ],
                            "type": "string"
                          }
                        },
                        "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                        "additionalProperties": false
                      }
                    },
                    "additionalProperties": false
                  },
                  "maxItems": 20
                },
                "combinator": {
                  "enum": [
                    "AND",
                    "OR"
                  ],
                  "type": "string"
                }
              },
              "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
              "additionalProperties": false
            },
            "periods": {
              "type": "integer",
              "maximum": 12,
              "minimum": 2,
              "description": "Periods each cohort is tracked for. Default 8."
            },
            "targetEvent": {
              "type": "string",
              "maxLength": 200,
              "description": "The event that puts a user in a cohort (e.g. \"signup\")."
            },
            "returningEvent": {
              "type": "string",
              "maxLength": 200,
              "description": "The event that counts as coming back (e.g. \"session_start\")."
            }
          },
          "additionalProperties": false
        },
        "sqlReason": {
          "type": "string",
          "maxLength": 300,
          "minLength": 10,
          "description": "For type \"sql\", required: why no funnel, retention or trends panel can show this."
        }
      },
      "additionalProperties": false
    }
    arguments 1536 lines
  • watch_issue unknown never probed

    After a fix for an issue ships, start a server-side check of whether it comes back: occurrences on the fix release (or the next release seen) and later, against how many sessions reached that release, over a horizon of up to 14 days. It keeps running after this session. Read the result later with get_watch. The result is never "fixed": it is recurred, no recurrence in N sessions, or not enough evidence.

    mcp-tool

    {
      "type": "object",
      "required": [
        "issueId"
      ],
      "properties": {
        "issueId": {
          "type": "string",
          "maxLength": 512,
          "description": "The issue id (from list_issues) or its Vinktar URL, as a person would paste it."
        },
        "release": {
          "type": "string",
          "maxLength": 64,
          "description": "The release that carries the fix, exactly as the SDK reports it. Omit to watch the next release first seen after now."
        },
        "environment": {
          "type": "string",
          "maxLength": 64,
          "description": "Only this environment, e.g. \"production\". Omit for every environment."
        },
        "horizonDays": {
          "type": "integer",
          "maximum": 14,
          "minimum": 1,
          "description": "How long to watch once the release is seen. Default 7."
        },
        "minExposure": {
          "type": "integer",
          "maximum": 100000,
          "minimum": 1,
          "description": "Sessions (or events) the release must reach before a clean result counts. Default 100."
        }
      },
      "additionalProperties": false
    }
    arguments 36 lines
  • add_panel unknown never probed

    Add a panel to a board. Each panel answers one question and reads at a glance: a number, a line or a bar. Build it from the structured types; `sql` is the last resort. Choose in this order: `funnel` for conversion through ordered events (viewed pricing → started checkout → paid), with a breakdown for conversion per segment (per shop, per plan): always a funnel, never a query or trend lines per step. `retention` for whether people come back. `trends` for everything that counts or sums events: `chart` "scalar" for one number (revenue, installs, failed charges; several numbers are several scalar panels, never one wide table), "line" for a metric over time, "bar" to compare segments with a breakdown; set `display.format` to "currency" for money and "percent" for a rate. A table only when the rows themselves are the point (the operations or shops to look at), with at most four columns. `issues` for the top errors, `text` for a heading over a row of panels. `sql` only when none of those can show it (a ratio between two measures), with at most four columns, the board's range as `{from}`/`{to}` rather than now(), and `sqlReason` saying why. A funnel and retention count the project's identified users: if the people in the question are not them, say so in a text panel instead. The spec is exactly what query_trends, query_funnel, query_retention or run_sql just ran (same field names), so check the numbers with that tool first. The panel is run once before it is saved: one that fails or breaks these rules is refused and nothing is saved, so follow the message and call again. The board is a grid: a panel joins the last row when it is the same kind and there is room (numbers up to four to a row, charts two, a table or text on its own), and every row shares its width equally at one height. Add panels in the order they should read; to change the rows afterwards, use update_board with `rows`.

    mcp-tool

    {
      "type": "object",
      "required": [
        "dashboardId",
        "name",
        "type"
      ],
      "properties": {
        "name": {
          "type": "string",
          "maxLength": 120,
          "description": "Panel title as the team will read it."
        },
        "text": {
          "type": "string",
          "maxLength": 2000,
          "description": "For type \"text\": the Markdown body. A heading for a row of panels, or a short note on how to read them. Your own words only: never paste captured data (error messages, payloads, URLs) into it."
        },
        "type": {
          "enum": [
            "funnel",
            "retention",
            "trends",
            "issues",
            "text",
            "sql"
          ],
          "type": "string",
          "description": "funnel, retention and trends first; sql only when they cannot express it."
        },
        "view": {
          "enum": [
            "steps",
            "timeToConvert",
            "trend",
            "bar",
            "table"
          ],
          "type": "string",
          "description": "Funnels only: steps (default, the drop-off per step), timeToConvert, trend (conversion rate over time), bar or table."
        },
        "chart": {
          "enum": [
            "line",
            "bar",
            "scalar",
            "table"
          ],
          "type": "string",
          "description": "For trends: line (default) over time, bar to compare segments, scalar for one number, table for rows. For retention: table (default, the cohort grid) or line (the average curve). For sql: table (default), line or bar."
        },
        "query": {
          "type": "string",
          "maxLength": 4096,
          "description": "For type \"sql\": the VinktarQL SELECT."
        },
        "funnel": {
          "type": "object",
          "required": [
            "steps"
          ],
          "properties": {
            "order": {
              "enum": [
                "ordered",
                "strict",
                "any"
              ],
              "type": "string",
              "description": "\"ordered\" (default): steps in sequence, other events allowed between; \"strict\": nothing between; \"any\": any order."
            },
            "steps": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "event"
                ],
                "properties": {
                  "event": {
                    "type": "string",
                    "maxLength": 200
                  },
                  "label": {
                    "type": "string",
                    "maxLength": 100
                  },
                  "filters": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "combinator"
                                ],
                                "properties": {
                                  "groups": {
                                    "type": "array",
                                    "maxItems": 0
                                  },
                                  "filters": {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "required": [
                                        "property",
                                        "op"
                                      ],
                                      "properties": {
                                        "op": {
                                          "enum": [
                                            "eq",
                                            "neq",
                                            "in",
                                            "contains",
                                            "gt",
                                            "lt",
                                            "is_set"
                                          ],
                                          "type": "string"
                                        },
                                        "values": {
                                          "type": "array",
                                          "items": {
                                            "type": "string",
                                            "maxLength": 1000
                                          },
                                          "maxItems": 100
                                        },
                                        "property": {
                                          "type": "object",
                                          "required": [
                                            "scope",
                                            "key"
                                          ],
                                          "properties": {
                                            "key": {
                                              "type": "string",
                                              "maxLength": 1000
                                            },
                                            "scope": {
                                              "enum": [
                                                "event",
                                                "context",
                                                "session",
                                                "user"
                                              ],
                                              "type": "string"
                                            }
                                          },
                                          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                          "additionalProperties": false
                                        }
                                      },
                                      "additionalProperties": false
                                    },
                                    "maxItems": 10
                                  },
                                  "combinator": {
                                    "enum": [
                                      "AND",
                                      "OR"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                                "additionalProperties": false
                              },
                              "maxItems": 5
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 20
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 10,
              "minItems": 2,
              "description": "Ordered steps: {event, label?, filters?}."
            },
            "filters": {
              "type": "object",
              "required": [
                "combinator"
              ],
              "properties": {
                "groups": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "maxItems": 0
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 10
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  },
                  "maxItems": 5
                },
                "filters": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "property",
                      "op"
                    ],
                    "properties": {
                      "op": {
                        "enum": [
                          "eq",
                          "neq",
                          "in",
                          "contains",
                          "gt",
                          "lt",
                          "is_set"
                        ],
                        "type": "string"
                      },
                      "values": {
                        "type": "array",
                        "items": {
                          "type": "string",
                          "maxLength": 1000
                        },
                        "maxItems": 100
                      },
                      "property": {
                        "type": "object",
                        "required": [
                          "scope",
                          "key"
                        ],
                        "properties": {
                          "key": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "scope": {
                            "enum": [
                              "event",
                              "context",
                              "session",
                              "user"
                            ],
                            "type": "string"
                          }
                        },
                        "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                        "additionalProperties": false
                      }
                    },
                    "additionalProperties": false
                  },
                  "maxItems": 20
                },
                "combinator": {
                  "enum": [
                    "AND",
                    "OR"
                  ],
                  "type": "string"
                }
              },
              "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
              "additionalProperties": false
            },
            "breakdown": {
              "type": "object",
              "required": [
                "scope",
                "key"
              ],
              "properties": {
                "key": {
                  "type": "string",
                  "maxLength": 1000
                },
                "scope": {
                  "enum": [
                    "event",
                    "context",
                    "session",
                    "user"
                  ],
                  "type": "string"
                }
              },
              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
              "additionalProperties": false
            },
            "conversionWindow": {
              "type": "object",
              "required": [
                "value",
                "unit"
              ],
              "properties": {
                "unit": {
                  "enum": [
                    "minute",
                    "hour",
                    "day",
                    "week",
                    "month"
                  ],
                  "type": "string"
                },
                "value": {
                  "type": "integer",
                  "maximum": 365,
                  "minimum": 1
                }
              },
              "description": "How long an entrant has to finish, e.g. {value: 1, unit: \"day\"}. Default 1 day.",
              "additionalProperties": false
            }
          },
          "additionalProperties": false
        },
        "issues": {
          "type": "object",
          "properties": {
            "sort": {
              "enum": [
                "occurrences",
                "users",
                "recent"
              ],
              "type": "string",
              "description": "Default \"occurrences\"."
            },
            "limit": {
              "type": "integer",
              "maximum": 10,
              "minimum": 1,
              "description": "Rows shown, default 5."
            },
            "environment": {
              "type": "string",
              "maxLength": 64,
              "description": "Only this environment, e.g. \"production\". Omit for all."
            }
          },
          "description": "For type \"issues\": the top error issues inside the board's window. Every field is optional.",
          "additionalProperties": false
        },
        "trends": {
          "type": "object",
          "required": [
            "series"
          ],
          "properties": {
            "series": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "aggregation"
                ],
                "properties": {
                  "event": {
                    "type": "string",
                    "maxLength": 200,
                    "description": "Event name; omit for all events."
                  },
                  "label": {
                    "type": "string",
                    "maxLength": 100
                  },
                  "filters": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "combinator"
                                ],
                                "properties": {
                                  "groups": {
                                    "type": "array",
                                    "maxItems": 0
                                  },
                                  "filters": {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "required": [
                                        "property",
                                        "op"
                                      ],
                                      "properties": {
                                        "op": {
                                          "enum": [
                                            "eq",
                                            "neq",
                                            "in",
                                            "contains",
                                            "gt",
                                            "lt",
                                            "is_set"
                                          ],
                                          "type": "string"
                                        },
                                        "values": {
                                          "type": "array",
                                          "items": {
                                            "type": "string",
                                            "maxLength": 1000
                                          },
                                          "maxItems": 100
                                        },
                                        "property": {
                                          "type": "object",
                                          "required": [
                                            "scope",
                                            "key"
                                          ],
                                          "properties": {
                                            "key": {
                                              "type": "string",
                                              "maxLength": 1000
                                            },
                                            "scope": {
                                              "enum": [
                                                "event",
                                                "context",
                                                "session",
                                                "user"
                                              ],
                                              "type": "string"
                                            }
                                          },
                                          "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                          "additionalProperties": false
                                        }
                                      },
                                      "additionalProperties": false
                                    },
                                    "maxItems": 10
                                  },
                                  "combinator": {
                                    "enum": [
                                      "AND",
                                      "OR"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                                "additionalProperties": false
                              },
                              "maxItems": 5
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 20
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  },
                  "property": {
                    "type": "object",
                    "required": [
                      "scope",
                      "key"
                    ],
                    "properties": {
                      "key": {
                        "type": "string",
                        "maxLength": 1000
                      },
                      "scope": {
                        "enum": [
                          "event",
                          "context",
                          "session",
                          "user"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                    "additionalProperties": false
                  },
                  "aggregation": {
                    "enum": [
                      "total",
                      "unique_users",
                      "unique_sessions",
                      "sum",
                      "avg",
                      "p95"
                    ],
                    "type": "string"
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 5,
              "minItems": 1,
              "description": "One to five metrics. Each: {event, aggregation, property?, filters?, label?}. `property` is required for sum, avg and p95."
            },
            "filters": {
              "type": "object",
              "required": [
                "combinator"
              ],
              "properties": {
                "groups": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "maxItems": 0
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 10
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  },
                  "maxItems": 5
                },
                "filters": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "property",
                      "op"
                    ],
                    "properties": {
                      "op": {
                        "enum": [
                          "eq",
                          "neq",
                          "in",
                          "contains",
                          "gt",
                          "lt",
                          "is_set"
                        ],
                        "type": "string"
                      },
                      "values": {
                        "type": "array",
                        "items": {
                          "type": "string",
                          "maxLength": 1000
                        },
                        "maxItems": 100
                      },
                      "property": {
                        "type": "object",
                        "required": [
                          "scope",
                          "key"
                        ],
                        "properties": {
                          "key": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "scope": {
                            "enum": [
                              "event",
                              "context",
                              "session",
                              "user"
                            ],
                            "type": "string"
                          }
                        },
                        "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                        "additionalProperties": false
                      }
                    },
                    "additionalProperties": false
                  },
                  "maxItems": 20
                },
                "combinator": {
                  "enum": [
                    "AND",
                    "OR"
                  ],
                  "type": "string"
                }
              },
              "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
              "additionalProperties": false
            },
            "breakdowns": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "scope",
                  "key"
                ],
                "properties": {
                  "key": {
                    "type": "string",
                    "maxLength": 1000
                  },
                  "scope": {
                    "enum": [
                      "event",
                      "context",
                      "session",
                      "user"
                    ],
                    "type": "string"
                  }
                },
                "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                "additionalProperties": false
              },
              "maxItems": 1,
              "description": "Split every series by one property."
            }
          },
          "additionalProperties": false
        },
        "display": {
          "type": "object",
          "properties": {
            "format": {
              "enum": [
                "count",
                "currency",
                "percent"
              ],
              "type": "string",
              "description": "currency for money, percent for a rate; default count."
            },
            "legend": {
              "type": "boolean",
              "description": "Line charts: show the legend. Default true."
            },
            "stacked": {
              "type": "boolean",
              "description": "Bar charts with several series: stack them. Default true."
            }
          },
          "description": "For trends and sql.",
          "additionalProperties": false
        },
        "projects": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 128
          },
          "maxItems": 50,
          "description": "The projects this panel reads, by handle or id: a panel keeps its own set, so one board can hold panels over different apps. Leave out for every project this connection reaches."
        },
        "retention": {
          "type": "object",
          "required": [
            "targetEvent",
            "returningEvent"
          ],
          "properties": {
            "period": {
              "enum": [
                "day",
                "week",
                "month"
              ],
              "type": "string",
              "description": "Cohort granularity. Default \"week\"."
            },
            "filters": {
              "type": "object",
              "required": [
                "combinator"
              ],
              "properties": {
                "groups": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "combinator"
                    ],
                    "properties": {
                      "groups": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "combinator"
                          ],
                          "properties": {
                            "groups": {
                              "type": "array",
                              "maxItems": 0
                            },
                            "filters": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "property",
                                  "op"
                                ],
                                "properties": {
                                  "op": {
                                    "enum": [
                                      "eq",
                                      "neq",
                                      "in",
                                      "contains",
                                      "gt",
                                      "lt",
                                      "is_set"
                                    ],
                                    "type": "string"
                                  },
                                  "values": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 1000
                                    },
                                    "maxItems": 100
                                  },
                                  "property": {
                                    "type": "object",
                                    "required": [
                                      "scope",
                                      "key"
                                    ],
                                    "properties": {
                                      "key": {
                                        "type": "string",
                                        "maxLength": 1000
                                      },
                                      "scope": {
                                        "enum": [
                                          "event",
                                          "context",
                                          "session",
                                          "user"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                                    "additionalProperties": false
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 10
                            },
                            "combinator": {
                              "enum": [
                                "AND",
                                "OR"
                              ],
                              "type": "string"
                            }
                          },
                          "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                          "additionalProperties": false
                        },
                        "maxItems": 5
                      },
                      "filters": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "property",
                            "op"
                          ],
                          "properties": {
                            "op": {
                              "enum": [
                                "eq",
                                "neq",
                                "in",
                                "contains",
                                "gt",
                                "lt",
                                "is_set"
                              ],
                              "type": "string"
                            },
                            "values": {
                              "type": "array",
                              "items": {
                                "type": "string",
                                "maxLength": 1000
                              },
                              "maxItems": 100
                            },
                            "property": {
                              "type": "object",
                              "required": [
                                "scope",
                                "key"
                              ],
                              "properties": {
                                "key": {
                                  "type": "string",
                                  "maxLength": 1000
                                },
                                "scope": {
                                  "enum": [
                                    "event",
                                    "context",
                                    "session",
                                    "user"
                                  ],
                                  "type": "string"
                                }
                              },
                              "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 10
                      },
                      "combinator": {
                        "enum": [
                          "AND",
                          "OR"
                        ],
                        "type": "string"
                      }
                    },
                    "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
                    "additionalProperties": false
                  },
                  "maxItems": 5
                },
                "filters": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "required": [
                      "property",
                      "op"
                    ],
                    "properties": {
                      "op": {
                        "enum": [
                          "eq",
                          "neq",
                          "in",
                          "contains",
                          "gt",
                          "lt",
                          "is_set"
                        ],
                        "type": "string"
                      },
                      "values": {
                        "type": "array",
                        "items": {
                          "type": "string",
                          "maxLength": 1000
                        },
                        "maxItems": 100
                      },
                      "property": {
                        "type": "object",
                        "required": [
                          "scope",
                          "key"
                        ],
                        "properties": {
                          "key": {
                            "type": "string",
                            "maxLength": 1000
                          },
                          "scope": {
                            "enum": [
                              "event",
                              "context",
                              "session",
                              "user"
                            ],
                            "type": "string"
                          }
                        },
                        "description": "{scope, key}. scope \"event\" = payload property, \"context\" = built-in dimension (country, browser, page_path, utm_source…), \"session\", \"user\" = user trait.",
                        "additionalProperties": false
                      }
                    },
                    "additionalProperties": false
                  },
                  "maxItems": 20
                },
                "combinator": {
                  "enum": [
                    "AND",
                    "OR"
                  ],
                  "type": "string"
                }
              },
              "description": "Filters combined with AND/OR: {combinator: \"AND\", filters: [{property: {scope, key}, op, values: [..]}], groups: [nested groups]}. Ops: eq, neq, in, contains, gt, lt, is_set. Values are strings.",
              "additionalProperties": false
            },
            "periods": {
              "type": "integer",
              "maximum": 12,
              "minimum": 2,
              "description": "Periods each cohort is tracked for. Default 8."
            },
            "targetEvent": {
              "type": "string",
              "maxLength": 200,
              "description": "The event that puts a user in a cohort (e.g. \"signup\")."
            },
            "returningEvent": {
              "type": "string",
              "maxLength": 200,
              "description": "The event that counts as coming back (e.g. \"session_start\")."
            }
          },
          "additionalProperties": false
        },
        "sqlReason": {
          "type": "string",
          "maxLength": 300,
          "minLength": 10,
          "description": "For type \"sql\", required: why no funnel, retention or trends panel can show this."
        },
        "dashboardId": {
          "type": "string",
          "pattern": "^\\d{1,19}$",
          "description": "The board, from list_boards or create_board."
        }
      },
      "additionalProperties": false
    }
    arguments 1538 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id 35023ff4f304f128.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/35023ff4f304f128/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/35023ff4f304f128/badge.svg)](https://brick.blue/agent/35023ff4f304f128?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.