---
name: sentinelboard-mcp
description: Connect an AI agent to Sentinelboard MCP, verify access, and inspect or manage monitoring dashboards, monitors, alerts, and incidents.
---

# Sentinelboard MCP

Use this skill when asked to connect to Sentinelboard or work with its monitoring workspace. Complete connection setup and read-only verification before making workspace changes.

## Connection details

| Setting | Value |
| --- | --- |
| Server name | `sentinelboard` |
| Endpoint | `https://api.sentinelboard.com/mcp` |
| Transport | MCP Streamable HTTP, remote and stateless |
| Authentication | `Authorization: Bearer <MCP_TOKEN>` |
| Suggested environment variable | `SENTINELBOARD_MCP_TOKEN` |
| Token management | `https://sentinelboard.com/settings/mcp` |
| This skill | `https://sentinelboard.com/skills/sentinelboard-mcp/SKILL.md` |

Use a dedicated Sentinelboard MCP token beginning with `sb_mcp_`. A Sentinelboard sign-in session token or ingestion API key cannot replace it. This endpoint authenticates with an issued bearer token; it does not provide an OAuth login flow.

## Set up the connection

1. Identify the user's current MCP client and its supported remote-server configuration. Inspect existing configuration without printing secrets. Preserve other servers and unrelated settings. Reuse an existing correct `sentinelboard` entry instead of creating a duplicate.
2. Check whether `SENTINELBOARD_MCP_TOKEN` or a client-managed secret is available, without exposing its value. If missing, guide the user to create a token in [AI agent settings](https://sentinelboard.com/settings/mcp). Recommend **Read only** for inspection; use **Read and write** only when the user's task requires changes. Tokens expire and can be revoked individually. The secret is displayed only once.
3. Have the user enter the token through a masked secret field, password manager, or environment configuration. Do not ask them to paste it into chat. Keep the secret out of prompts, tracked files, command history, logs, screenshots, and diagnostic output. Check only whether a secret is present, never print it to verify it.
4. Register the remote endpoint using the client's native MCP configuration and secure bearer-token support. Add only the settings needed for Sentinelboard. If the client cannot use a remote HTTP server with bearer authentication, explain the limitation and provide a compatible setup path; do not claim it is connected.
5. Make the secret available to the process that opens the MCP connection. A variable set in a terminal is not automatically available to a separately launched desktop app or hosted agent. Use the client's secret/environment settings or launch it from the configured environment.
6. Restart or reconnect the MCP client as needed, then verify with the read-only calls below. If configuration changes require a new session, tell the user exactly what to reopen.

### Codex

Set `SENTINELBOARD_MCP_TOKEN` securely in the environment used by Codex. Add or update this entry in `~/.codex/config.toml` (or the actual config under `CODEX_HOME` if customized):

```toml
[mcp_servers.sentinelboard]
url = "https://api.sentinelboard.com/mcp"
bearer_token_env_var = "SENTINELBOARD_MCP_TOKEN"
```

The config contains the environment variable's name, not its secret value. Preserve the rest of the file and avoid duplicate TOML tables. Project-scoped `.codex/config.toml` is also supported for trusted projects; preserve the user's existing scope.

When the Codex CLI is available, `codex mcp list` checks registration. Registration alone does not prove a successful connection: verify by calling a Sentinelboard tool in the client. Do not run `codex mcp login sentinelboard`; this endpoint uses the dedicated token rather than OAuth.

See [official Codex MCP configuration](https://developers.openai.com/codex/mcp/) for client-specific details.

### Other MCP clients

Configure a remote **Streamable HTTP** server named `sentinelboard` with the endpoint above. Set the `Authorization` header to `Bearer <MCP_TOKEN>` through the client's secret input or supported environment-variable reference. Use that client's documented syntax; do not assume every client supports `${ENV_VAR}` interpolation. Do not configure this hosted server as a local stdio process or a legacy SSE endpoint.

### Direct protocol diagnostics

Prefer the MCP client's built-in transport. If debugging with an MCP SDK or HTTP requests, follow the MCP lifecycle: `initialize`, `notifications/initialized`, then `tools/list` and `tools/call`. Negotiate a supported protocol version during initialization and send `MCP-Protocol-Version` on subsequent requests. Send the bearer token on every request, `Content-Type: application/json` on JSON requests, and `Accept: application/json, text/event-stream` on POST requests. The server is stateless and does not require sticky sessions.

A plain browser GET to `/mcp` is not a connection test. Never include credentials in a diagnostic command's literal text or output.

## Verify before reporting success

1. Discover the live tools through MCP `tools/list` or the client's tool discovery.
2. Call `sentinelboard_get_capabilities` with `{}` to confirm the server responds and learn its supported operations.
3. Call `sentinelboard_get_overview` with `{}` to verify authenticated workspace access. Do not create or update anything as a connection test.
4. Report the configured endpoint, whether tool calls succeeded, and the token's access level when known from its creation metadata or the user's token settings. **The capabilities response's `access` array lists supported token modes; it does not identify the current token's permissions.** The tool catalog can advertise write tools even for a read-only token. If the current access level is unknown, say so; do not probe it with a write operation.

Only report a working connection after a successful authenticated tool response. If only the configuration is complete, report that verification is pending.

## Discover and use the tools

The live tool schemas are authoritative for names, arguments, required fields, and supported enums. Discover them instead of guessing request payloads. Start with a read to locate the correct resource IDs.

| Task | Read tools |
| --- | --- |
| Workspace and dashboards | `sentinelboard_get_overview`, `sentinelboard_list_dashboards`, `sentinelboard_get_dashboard` |
| Monitors and events | `sentinelboard_list_metrics`, `sentinelboard_get_metric`, `sentinelboard_get_metric_history` |
| Alert rules | `sentinelboard_list_alerts` |
| Incidents | `sentinelboard_list_incidents`, `sentinelboard_get_incident` |
| Application error groups | `sentinelboard_list_error_logs`, `sentinelboard_get_error_log` |
| Servers, resources and PostgreSQL | `sentinelboard_list_servers`, `sentinelboard_get_server` |
| Server vulnerabilities | `sentinelboard_list_security_findings`, `sentinelboard_get_security_finding` |
| Live public checks | `sentinelboard_check_web_availability`, `sentinelboard_check_ssl_certificate` |

For server questions, start with `sentinelboard_list_servers`, then `sentinelboard_get_server` for resource values and PostgreSQL databases. For vulnerabilities, `sentinelboard_list_security_findings` defaults to the `attention` filter (what raises alerts); use `all` to see everything. It pages by number: pass `next_page` until it is null.

Paginated list tools return `items` and `next_cursor`. Pass the returned cursor to continue until it is null. The default limit is 50 and the maximum is 100. History and error tools have their own limits and filters; use their live schemas.

Read/write tokens additionally support creating and updating monitors, enabling/disabling them, archiving/restoring them, completing/postponing reminders, recording numeric/heartbeat events, creating/updating dashboards and alert rules, moving dashboard memberships, updating incidents, and dismissing error groups.

### Supported monitor creation

Use `sentinelboard_create_metric` and its discovered schema. Every creation requires `kind`, `name`, `config`, and an `idempotency_key`; `dashboard_id` is optional.

| Kind | Required `config` fields |
| --- | --- |
| `web_availability` | `url`; optional `regions` (`US`, `EU`, `ASIA`) |
| `api_call` | `url`; optional `method`, `headers`, `body`, `expected_response_fragments` |
| `ssl_health` | `hostname` |
| `domain_expiration` | `domain` |
| `heartbeat` | None; optional `period_hours` |
| `numeric` | None; optional `unit`, `unit_position`, `aggregation`, `reversed` |
| `stock` / `crypto` | `ticker` |
| `rss` | `url` |
| `reminder` | `occurs_at` (ISO 8601) |
| `periodic_event` | `occurs_at` and `period_hours` |

Inbox, error-ingestion, OpenRouter trace, OpenRouter credit, server telemetry, server security and server status monitors can be read but cannot be created through MCP. Their setup requires the corresponding Sentinelboard integration flow.

### Writes and retries

- Respect the user's requested scope. Read the existing resource before changing it, and use only an owned resource for writes. Shared dashboards may be read, but shared resources are not writable through this token.
- Do not change anything just to verify access. Read/write credentials enable changes; they are not instructions to make changes.
- Follow the live schema's `idempotency_key` requirements. Creation, event recording, reminder completion/postponement, and adding monitors to dashboards require keys. Generate one stable key per intended action, and reuse it for retries of that same action with the same payload. Use a new key for a different intended action.
- A repeated key can replay the original success, a recorded failure, or `request_in_progress`. If still processing, wait briefly and retry with the same key. After a validation error, inspect and correct the request; a corrected payload is a new action and needs a new key. Do not blindly retry a write that lacks idempotency protection after an uncertain result; read back its state first.
- There are no permanent-delete tools. Archive a monitor to remove it from active views, restore it to undo the archive, or remove only its dashboard membership when that is the user's intent.
- Treat `isError` or a structured `error` result as failure even when HTTP succeeded. Report a completed change only when the tool response confirms it. Keep integration credentials and private payloads out of reports.

## Troubleshooting

| Symptom | Next step |
| --- | --- |
| HTTP `401`: invalid or expired MCP access token | Check that the correct dedicated token is present in the connecting process and the header is `Authorization: Bearer …`. Check expiration/revocation in settings; create a replacement if needed. Never display the secret. |
| `read_only_token` | The requested operation requires a read/write token. Continue with reads or guide the user to create the appropriate token for their requested change. |
| `not_found` or ownership error | Re-list accessible resources and use the correct ID. Do not substitute another user's resource or bypass ownership checks. |
| `validation_failed`, `invalid_argument`, or schema rejection | Read the discovered schema and error message, correct the arguments, and follow the idempotency rules above. |
| `idempotency_key_required` | Supply a stable key for the intended action. |
| `request_in_progress` | Wait briefly and retry the same action with the same key. |
| Connection configured but no tools appear | Check the actual client config/scope, inherited secret, enabled server, transport, and whether a restart/new session is required. |
| HTTP `403`, `404`, or transport failure | Check the exact endpoint, network access, client transport, and any Origin restrictions. The endpoint may be disabled; do not work around origin or access controls. |
| Live check rejects a target | Availability and SSL checks accept public targets; private/internal targets are blocked. |

Requests are limited to 1 MiB. Reduce oversized arguments rather than repeatedly sending the same payload. For persistent errors, report the failing operation and sanitized error code/message without credentials.
