How to use MCP for monitoring and alerting

1// src/sentry-tools.ts
2import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
3import { z } from "zod";
4
5const SENTRY_TOKEN = process.env.SENTRY_AUTH_TOKEN!;
6const SENTRY_ORG = process.env.SENTRY_ORG!;
7
8async function sentryApi(path: string) {
9  const res = await fetch(`https://sentry.io/api/0${path}`, {
10    headers: { Authorization: `Bearer ${SENTRY_TOKEN}` },
11  });
12  return res.json();
13}
14
15export function registerSentryTools(server: McpServer) {
16  server.tool("get_recent_errors", "Get recent error issues from Sentry", {
17    project: z.string().describe("Sentry project slug"),
18    hours: z.number().default(24).describe("Look back period in hours"),
19    limit: z.number().default(10),
20  }, async ({ project, hours, limit }) => {
21    const since = new Date(Date.now() - hours * 3600000).toISOString();
22    const issues = await sentryApi(
23      `/projects/${SENTRY_ORG}/${project}/issues/?query=is:unresolved&sort=freq&limit=${limit}&start=${since}`
24    );
25    const summary = issues.map((i: any) => ({
26      id: i.id, title: i.title, count: i.count, level: i.level,
27      firstSeen: i.firstSeen, lastSeen: i.lastSeen, culprit: i.culprit,
28    }));
29    return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
30  });
31
32  server.tool("get_error_details", "Get full details and stack trace for a Sentry issue", {
33    issueId: z.string().describe("Sentry issue ID"),
34  }, async ({ issueId }) => {
35    const events = await sentryApi(`/issues/${issueId}/events/latest/`);
36    const trace = events.entries?.find((e: any) => e.type === "exception");
37    return { content: [{ type: "text", text: JSON.stringify({
38      message: events.message,
39      tags: events.tags,
40      stackTrace: trace?.data?.values?.map((v: any) => ({
41        type: v.type, value: v.value,
42        frames: v.stacktrace?.frames?.slice(-5).map((f: any) => ({
43          filename: f.filename, function: f.function, lineNo: f.lineNo, context: f.context,
44        })),
45      })),
46    }, null, 2) }] };
47  });
48}

1// src/datadog-tools.ts
2import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
3import { z } from "zod";
4
5const DD_API_KEY = process.env.DD_API_KEY!;
6const DD_APP_KEY = process.env.DD_APP_KEY!;
7
8async function datadogApi(path: string, params?: Record<string, string>) {
9  const url = new URL(`https://api.datadoghq.com/api/v1${path}`);
10  if (params) Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
11  const res = await fetch(url, {
12    headers: { "DD-API-KEY": DD_API_KEY, "DD-APPLICATION-KEY": DD_APP_KEY },
13  });
14  return res.json();
15}
16
17export function registerDatadogTools(server: McpServer) {
18  server.tool("get_active_alerts", "Get currently active Datadog monitors/alerts", {
19    tag: z.string().optional().describe("Filter by tag, e.g. service:api"),
20  }, async ({ tag }) => {
21    const monitors = await datadogApi("/monitor", {
22      ...(tag ? { monitor_tags: tag } : {}),
23    });
24    const active = monitors
25      .filter((m: any) => m.overall_state === "Alert" || m.overall_state === "Warn")
26      .map((m: any) => ({ id: m.id, name: m.name, state: m.overall_state, message: m.message }));
27    return { content: [{ type: "text", text: JSON.stringify(active, null, 2) }] };
28  });
29
30  server.tool("query_metrics", "Query Datadog metrics for a time range", {
31    query: z.string().describe("Datadog metric query, e.g. avg:system.cpu.user{service:api}"),
32    hours: z.number().default(1).describe("Look back period in hours"),
33  }, async ({ query, hours }) => {
34    const now = Math.floor(Date.now() / 1000);
35    const from = now - hours * 3600;
36    const result = await datadogApi("/query", {
37      query, from: String(from), to: String(now),
38    });
39    const series = result.series?.map((s: any) => ({
40      metric: s.metric, scope: s.scope,
41      points: s.pointlist?.slice(-10).map((p: any) => ({
42        time: new Date(p[0]).toISOString(), value: p[1]?.toFixed(2),
43      })),
44    }));
45    return { content: [{ type: "text", text: JSON.stringify(series, null, 2) }] };
46  });
47}

1// Complete MCP config with all monitoring + code servers:
2{
3  "mcpServers": {
4    "sentry": {
5      "command": "node",
6      "args": ["dist/monitoring-server.js"],
7      "env": {
8        "SENTRY_AUTH_TOKEN": "sntrys_...",
9        "SENTRY_ORG": "your-org"
10      }
11    },
12    "datadog": {
13      "command": "node",
14      "args": ["dist/datadog-server.js"],
15      "env": {
16        "DD_API_KEY": "your-dd-api-key",
17        "DD_APP_KEY": "your-dd-app-key"
18      }
19    },
20    "codebase": {
21      "command": "npx",
22      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/repo"]
23    }
24  }
25}
26
27// Example incident investigation prompt:
28// "We got paged for high error rates. Check Sentry for recent errors in the
29//  api-gateway project, look at the stack traces, read the relevant source
30//  files, and check Datadog for any infrastructure anomalies. Give me a
31//  root cause analysis and suggested fix."

1server.tool(
2  "triage_incident",
3  "Automated incident triage: checks errors and metrics, returns severity assessment",
4  {
5    project: z.string().describe("Sentry project slug"),
6    service: z.string().describe("Service tag for Datadog metrics"),
7  },
8  async ({ project, service }) => {
9    // Fetch recent errors
10    const issues = await sentryApi(
11      `/projects/${SENTRY_ORG}/${project}/issues/?query=is:unresolved&sort=date&limit=5`
12    );
13
14    // Fetch active alerts
15    const monitors = await datadogApi("/monitor", { monitor_tags: `service:${service}` });
16    const activeAlerts = monitors.filter((m: any) =>
17      m.overall_state === "Alert" || m.overall_state === "Warn"
18    );
19
20    // Assess severity
21    const errorCount = issues.reduce((sum: number, i: any) => sum + i.count, 0);
22    const severity = activeAlerts.length > 2 || errorCount > 100 ? "CRITICAL"
23      : activeAlerts.length > 0 || errorCount > 10 ? "HIGH" : "LOW";
24
25    const triage = {
26      severity,
27      timestamp: new Date().toISOString(),
28      errorSummary: {
29        totalErrors: errorCount,
30        topIssues: issues.slice(0, 3).map((i: any) => ({ title: i.title, count: i.count })),
31      },
32      activeAlerts: activeAlerts.map((m: any) => ({ name: m.name, state: m.overall_state })),
33      recommendation: severity === "CRITICAL"
34        ? "Immediate investigation required. Multiple alerts active."
35        : severity === "HIGH"
36        ? "Investigate soon. Error rates elevated."
37        : "Monitor. Low error rates, no active alerts.",
38    };
39
40    return { content: [{ type: "text", text: JSON.stringify(triage, null, 2) }] };
41  }
42);