On My Radar
On this page

Guides Agents and MCP

MCP tools for dashboards and RSS feeds

Reference for the ten MCP tools that read and arrange your personal dashboards and that manage RSS and Atom subscriptions on a radar.

Updated October 30, 2026 · Checked against On My Radar build 2c4905d

These ten tools cover two jobs: building your personal dashboard tabs, and subscribing a radar to an RSS or Atom feed. Ids and scopes are explained in the MCP reference overview. For the screen itself, see Dashboards.

Dashboards

A dashboard is a personal tab holding radar panels and live query widgets. Tabs are private to their owner and grant no access to any radar. Every call checks your current radar access again, so a widget never shows something you could not search for yourself.

The grid has 12 columns. A dashboard holds up to 60 panels, up to 12 of which can be live queries. Count tiles can be 2 by 2. Lists and charts need at least 3 columns and 4 rows. Panels cannot overlap.

A radar panel has radarId set and config of { "type": "radar", "hideWhenEmpty": true }. A query widget has radarId: null and a config with these fields:

  • type: query.
  • title (1 to 120 characters).
  • query (up to 500 characters): the same search grammar as search_blips.
  • limit (1 to 50, default 12).
  • display: list, count, lanes or activity.
  • groupByRadar (boolean, for lists).
  • activityDays: 7, 30 or 90 (UTC days, for activity).
  • hideWhenEmpty (boolean). This is presentation only and never deletes a widget.

list_dashboards

Reads your dashboard tabs, including every widget's id, layout and configuration. Use it before changing a layout so you can preserve existing panels.

  • Scope: radars:read. Read-only.
  • Arguments: none.
  • Returns: each tab with id, revision, name, position and widgets (each with id, radarId, x, y, w, h, config).

create_dashboard

Creates an empty personal dashboard tab. Then use update_dashboard with the returned id to add panels.

  • Scope: radars:write. Writes.
  • Required: name (1 to 120 characters).
  • Returns: the new tab.

update_dashboard

Renames or arranges a personal dashboard. Choose exactly one of widgets, append or operations in each call.

  • Scope: radars:write, and you must own the tab. Writes. Marked destructive, because widgets replaces the whole layout.
  • Required: dashboardId (UUID), plus at least one change.
  • Optional:
    • name (up to 120) and position (integer 0 to 500).
    • append (1 to 60 items): new widgets, each { radarId, config, w?, h? }. They are packed into free space against the latest layout. This is the preferred way to add panels.
    • operations (1 to 120 items): atomic changes to individual widgets. Each is one of { "op": "add", "widget": {...}, "x"?, "y"? }, { "op": "remove", "id" }, { "op": "move", "id", "x", "y", "w"?, "h"? } or { "op": "update", "id", "radarId"?, "config"? }. Unrelated panels are preserved.
    • widgets (up to 60): a full replacement of the layout. Each has id (optional), radarId, config, x (0 to 11), y (0 to 400), w (2 to 12) and h (2 to 40). It requires expectedRevision.
    • expectedRevision (integer): the revision from list_dashboards. A stale value is refused instead of overwriting newer panels. Reload and review rather than retrying blindly.
  • Returns: the updated tab.

Unknown keys are rejected. append and operations merge with the latest layout, so they are safe to use without reading coordinates first. A new widget without w and h gets 6 by 8, or 2 by 2 for a count tile. A radar panel must name a radar you can read, and a query widget whose filters do not resolve is refused, so check it with preview_dashboard_query first.

{
  "dashboardId": "0c6f1b9e-3d2a-4c77-8b14-2f5a9e6d7c03",
  "append": [
    {
      "radarId": null,
      "config": {
        "type": "query",
        "title": "In progress",
        "query": "is:active",
        "display": "count",
        "hideWhenEmpty": true
      }
    }
  ]
}

delete_dashboard

Deletes one personal dashboard tab and its layout. The radars and blips shown in it are untouched.

  • Scope: radars:write, and you must own the tab. Writes, and cannot be undone.
  • Required: dashboardId (UUID).
  • Returns: { "deleted": "<dashboardId>" }.

preview_dashboard_query

Tries a live query before you save it. Resolve any problems first. unresolved: true means fix the filter, not that nothing matched.

  • Scope: radars:read. Read-only.
  • Required: query (up to 500 characters). An empty string browses all readable radars.
  • Optional: limit (1 to 50, default 12), display (list, count, lanes, activity), groupByRadar (boolean), activityDays (7, 30, 90).
  • Returns: matching items, the resolved filters, problems, unresolved and total.

total counts every matching blip, independent of limit. Use search_blips to page through more than 50.

{ "query": "in:\"Work\" in:\"Reading\" is:inbox", "display": "count" }

read_dashboard_widget

Runs one saved query widget using its current query and limit.

  • Scope: radars:read. Read-only.
  • Required: dashboardId (UUID), widgetId (UUID). Get both from list_dashboards.

For a single-radar panel, call read_radar with its radarId instead.

RSS and Atom feeds

A feed subscription imports entries from a public RSS or Atom URL into a radar as blips. Imports run in the background and skip entries already imported, even if you remove and re-add the feed. The same limits apply as in the web app.

These tools need radars:manage and actual ownership of the radar, including for reads.

  • An account can have at most 50 active feeds, and a radar at most 10.
  • A smart radar cannot take a feed.
  • A poll reads at most 2 MiB of feed data and captures at most 500 entries per run, continuing later if there are more.
  • Only entries the feed still supplies can be imported. A finite history window leaves out undated entries.

list_feeds

Lists the RSS and Atom subscriptions on a radar you own, with their import status.

  • Scope: radars:manage. Read-only.
  • Required: radarId (UUID).
  • Returns: each feed with id, url, title, lookback, enabled, lastPolledAt, lastSuccessAt, lastError, itemCount and createdAt.

create_feed

Subscribes a radar you own to a public feed URL.

  • Scope: radars:manage. Writes.
  • Required:
    • radarId (UUID).
    • url: an http or https URL up to 2,048 characters, with no username or password, pointing at a public address.
    • lookback: how much history to import: forever, year, month, week or day.
  • Returns: the new feed.
{ "radarId": "5b2c7e2e-1f0a-4a55-9a53-0d1f6f3b8a10", "url": "https://example.com/feed.xml", "lookback": "month" }

update_feed

Pauses or resumes a subscription, or changes its import history. Existing blips stay.

  • Scope: radars:manage. Writes.
  • Required: radarId (UUID), feedId (UUID), plus at least one of the fields below.
  • Optional: enabled (boolean), lookback (forever, year, month, week, day).

delete_feed

Stops importing a feed. Existing blips and the small markers that prevent duplicates remain, so re-adding the feed does not recapture old entries.

  • Scope: radars:manage. Writes. Idempotent.
  • Required: radarId (UUID), feedId (UUID).
  • Returns: { "deleted": "<feedId>" }.

Next