Monitoring inside your AI assistant: connect Claude or Cursor to Pingvera in a minute

July 4, 2026 · 6 min read

You already spend half your day talking to your assistant: it writes code, reads logs, reviews PRs. The logical next step is for it to see production too. Ask "what's down for my clients right now?" or "what was this site's uptime this month?" — and get an answer from real monitoring numbers, not reasoning. That's what Pingvera's MCP server and plain REST API are for. Connecting to Claude Code is one command; to Cursor, one JSON block. Let's walk through it.

Why monitoring belongs in the assistant

The classic scenario: you're in your editor, a message lands — "something's wrong with the client's site." Then comes the context switch to the dashboard, hunting for the right monitor, cross-checking event times. Your assistant can do all of that for you without leaving your working context:

• "What's down right now?" — a list of open events across all checks;
• "What's the uptime for site.com over the last 30 days?" — a percentage computed from real checks;
• "Which servers are offline right now?" — the state of the fleet with agents;
• "Pull together an incident summary for the past week for a client report" — the assistant pulls the events itself and writes it up.

The key difference from "asking an LLM about monitoring" is that the answers are built on your data, which the assistant fetches through tools rather than inventing.

Step 1. Issue an API token

Tokens are created in the dashboard: Settings → API. Each token has its own set of scopes — its access areas:

• read:monitoring — checks, events, and uptime (works for both REST and MCP);
• read:hosts — servers with agents;
• read:metrics — metric time series (CPU, memory, etc.).

The token secret is shown once at creation — save it right away. If a token is no longer needed or ends up in the wrong hands, it can be revoked at any time in the same place, in settings.

Step 2. Connect the MCP server

MCP (Model Context Protocol) is an open protocol that assistants use to connect to external data. The Pingvera MCP server lives at https://app.pingvera.com/mcp and speaks plain HTTP transport.

Claude Code — one command

claude mcp add --transport http pingvera https://app.pingvera.com/mcp \
  --header "Authorization: Bearer pv_YOUR_TOKEN"

That's it. After this, the Pingvera tools show up in your Claude Code session, and when you ask about outages the assistant goes to your monitoring instead of its general knowledge.

Cursor and other MCP clients — JSON config

Where MCP is configured with a file, an mcpServers block with the address and an authorization header is enough:

{
  "mcpServers": {
    "pingvera": {
      "url": "https://app.pingvera.com/mcp",
      "headers": {
        "Authorization": "Bearer pv_YOUR_TOKEN"
      }
    }
  }
}

What tools the assistant gets

• list_monitors — a list of checks with current up/down status;
• list_incidents — events: what's open now and the history for a period;
• list_hosts — servers with agents, online or offline;
• uptime_summary — uptime as a percentage for a chosen period.

The assistant knows how to combine them on its own: for "make me a weekly summary" it will call both the events and the uptime and weave the responses into coherent text.

Without MCP: the plain REST API

MCP is a convenience layer for assistants. Underneath it is a plain website monitoring API you can use from scripts, bots, and your own integrations. Auth is the same Bearer token:

curl -H "Authorization: Bearer pv_YOUR_TOKEN" \
  "https://app.pingvera.com/api/v1/incidents?status=open"

The main read endpoints:

• GET /api/v1/monitors — checks and their statuses;
• GET /api/v1/incidents — events (?status=open — open only);
• GET /api/v1/hosts — servers with agents;
• GET /api/v1/metrics/query — host metric time series (host=...&metrics=cpu_pct,mem_used_pct and others).

Full description is in the OpenAPI spec: app.pingvera.com/api/v1/openapi.json. Integration details are collected on the developer page.

What if we use a different LLM?

MCP isn't required. Any LLM with function calling works: describe the functions from the OpenAPI spec and the model decides on its own when to hit /monitors and when /incidents. From your code's side these are ordinary HTTPS requests with a Bearer token — no SDK needed.

Why it's safe: read-only, by design

Handing an AI agent access to infrastructure is a fair reason to be paranoid. That's why an architectural property of Pingvera matters here: there are no write operations in the API at all. Neither via MCP nor via REST can you create, change, stop, or delete a check — you can only read data.

Same on the server side: the Pingvera agent is one-way — it sends metrics and accepts no commands from outside. Even a leaked token gives an attacker (or an overly enterprising assistant) nothing to break: at most, a look at statuses. And revoking a token is one click in "Settings → API."

The practical takeaway: you can connect monitoring to your assistant without building a sandbox around it. The worst case is an extra glance at uptime.

Frequently asked questions

What is a monitoring MCP server and why would I want one?

MCP (Model Context Protocol) is an open protocol that lets AI assistants like Claude or Cursor connect to external data sources. The Pingvera MCP server gives the assistant read tools: a list of checks with their statuses, events over a period, servers online/offline, and uptime as a percentage. The assistant decides which tool to call and answers your question with real monitoring data instead of guesses.

Can the assistant break something in monitoring through the API?

No. Both the MCP server and the Pingvera REST API are read-only — there are no write operations at all. The agent on the server is one-way too: it sends metrics and accepts no commands. Even if a token leaks, it can't stop, change, or delete anything — only view. And the token itself is revoked in one click in the dashboard.

Do I need a paid plan to try MCP and the API?

No. The free plan covers up to 5 sites with checks from 1 minute — enough to set up real checks, issue an API token, and connect an assistant. The MCP server and REST API work on any plan.

Read also: Pingvera for developers: API, MCP, and the OpenAPI spec and Site not working: how to check availability the right way.