Skip to main content
Glama
Datadog MCP Server

Datadog MCP Server

Datadog MCP Server

DISCLAIMER: This is a community-maintained project and is not officially affiliated with, endorsed by, or supported by Datadog, Inc. This MCP server utilizes the Datadog API but is developed independently as part of the Model Context Protocol ecosystem.

NPM VersionBuild and Testcodecov

MCP server for the Datadog API, enabling incident management and more.

Features

  • Observability Tools: Provides a mechanism to leverage key Datadog monitoring features, such as incidents, monitors, logs, dashboards, and metrics, through the MCP server.

  • Extensible Design: Designed to easily integrate with additional Datadog APIs, allowing for seamless future feature expansion.

Related MCP server: MCP Datadog Server

Tools

  1. list_incidents

    • Retrieve a list of incidents from Datadog.

    • Inputs:

      • filter (optional string): Filter parameters for incidents (e.g., status, priority).

      • pagination (optional object): Pagination details like page size/offset.

    • Returns: Array of Datadog incidents and associated metadata.

  2. get_incident

    • Retrieve detailed information about a specific Datadog incident.

    • Inputs:

      • incident_id (string): Incident ID to fetch details for.

    • Returns: Detailed incident information (title, status, timestamps, etc.).

  3. get_monitors

    • Fetch the status of Datadog monitors.

    • Inputs:

      • groupStates (optional array): States to filter (e.g., alert, warn, no data, ok).

      • name (optional string): Filter by name.

      • tags (optional array): Filter by tags.

    • Returns: Monitors data and a summary of their statuses.

  4. get_logs

    • Search and retrieve logs from Datadog.

    • Inputs:

      • query (string): Datadog logs query string.

      • from (number): Start time in epoch seconds.

      • to (number): End time in epoch seconds.

      • limit (optional number): Maximum number of logs to return (defaults to 100).

    • Returns: Array of matching logs.

  5. list_dashboards

    • Get a list of dashboards from Datadog.

    • Inputs:

      • name (optional string): Filter dashboards by name.

      • tags (optional array): Filter dashboards by tags.

    • Returns: Array of dashboards with URL references.

  6. get_dashboard

    • Retrieve a specific dashboard from Datadog.

    • Inputs:

      • dashboard_id (string): ID of the dashboard to fetch.

    • Returns: Dashboard details including title, widgets, etc.

  7. query_metrics

    • Retrieve metrics data from Datadog.

    • Inputs:

      • query (string): Metrics query string.

      • from (number): Start time in epoch seconds.

      • to (number): End time in epoch seconds.

    • Returns: Metrics data for the queried timeframe.

  8. list_traces

    • Retrieve a list of APM traces from Datadog.

    • Inputs:

      • query (string): Datadog APM trace query string.

      • from (number): Start time in epoch seconds.

      • to (number): End time in epoch seconds.

      • limit (optional number): Maximum number of traces to return (defaults to 100).

      • sort (optional string): Sort order for traces (defaults to '-timestamp').

      • service (optional string): Filter by service name.

      • operation (optional string): Filter by operation name.

    • Returns: Array of matching traces from Datadog APM.

  9. list_spans

    • Get a list of spans matching a search query (Datadog Spans Search API).

    • Inputs:

      • query (string): Search query following spans syntax.

      • from (number): Minimum timestamp for requested spans (epoch seconds).

      • to (number): Maximum timestamp for requested spans (epoch seconds).

      • sort (optional string): Order of spans in results ('timestamp' | '-timestamp').

      • cursor (optional string): Pagination cursor from previous request.

      • limit (optional number): Maximum number of spans to return (default 100).

    • Returns: Spans list, count, and next cursor when available.

  10. list_hosts

  • Get list of hosts from Datadog.

  • Inputs:

    • filter (optional string): Filter string for search results.

    • sort_field (optional string): Field to sort hosts by.

    • sort_dir (optional string): Sort direction (asc/desc).

    • start (optional number): Starting offset for pagination.

    • count (optional number): Max number of hosts to return (max: 1000).

    • from (optional number): Search hosts from this UNIX timestamp.

    • include_muted_hosts_data (optional boolean): Include muted hosts status and expiry.

    • include_hosts_metadata (optional boolean): Include host metadata (version, platform, etc).

  • Returns: Array of hosts with details including name, ID, aliases, apps, mute status, and more.

  1. get_active_hosts_count

    • Get the total number of active hosts in Datadog.

    • Inputs:

      • from (optional number): Number of seconds from which you want to get total number of active hosts (defaults to 2h).

    • Returns: Count of total active and up hosts.

  2. mute_host

    • Mute a host in Datadog.

    • Inputs:

      • hostname (string): The name of the host to mute.

      • message (optional string): Message to associate with the muting of this host.

      • end (optional number): POSIX timestamp for when the mute should end.

      • override (optional boolean): If true and the host is already muted, replaces existing end time.

    • Returns: Success status and confirmation message.

  3. unmute_host

    • Unmute a host in Datadog.

    • Inputs:

      • hostname (string): The name of the host to unmute.

    • Returns: Success status and confirmation message.

  4. list_downtimes

    • List scheduled downtimes from Datadog.

    • Inputs:

      • currentOnly (optional boolean): Return only currently active downtimes when true.

      • monitorId (optional number): Filter by monitor ID.

    • Returns: Array of scheduled downtimes with details including scope, monitor information, and schedule.

  5. schedule_downtime

    • Schedule a downtime in Datadog.

    • Inputs:

      • scope (string): Scope to apply downtime to (e.g. 'host:my-host').

      • start (optional number): UNIX timestamp for the start of the downtime.

      • end (optional number): UNIX timestamp for the end of the downtime.

      • message (optional string): A message to include with the downtime.

      • timezone (optional string): The timezone for the downtime (e.g. 'UTC', 'America/New_York').

      • monitorId (optional number): The ID of the monitor to mute.

      • monitorTags (optional array): A list of monitor tags for filtering.

      • recurrence (optional object): Recurrence settings for the downtime.

        • type (string): Recurrence type ('days', 'weeks', 'months', 'years').

        • period (number): How often to repeat (must be >= 1).

        • weekDays (optional array): Days of the week for weekly recurrence.

        • until (optional number): UNIX timestamp for when the recurrence ends.

    • Returns: Scheduled downtime details including ID and active status.

  6. cancel_downtime

    • Cancel a scheduled downtime in Datadog.

    • Inputs:

      • downtimeId (number): The ID of the downtime to cancel.

    • Returns: Confirmation of downtime cancellation.

  7. get_rum_applications

    • Get all RUM applications in the organization.

    • Inputs: None.

    • Returns: List of RUM applications.

  8. get_rum_events

    • Search and retrieve RUM events from Datadog.

    • Inputs:

      • query (string): Datadog RUM query string.

      • from (number): Start time in epoch seconds.

      • to (number): End time in epoch seconds.

      • limit (optional number): Maximum number of events to return (default: 100).

    • Returns: Array of RUM events.

  9. get_rum_grouped_event_count

    • Search, group and count RUM events by a specified dimension.

    • Inputs:

      • query (optional string): Additional query filter for RUM search (default: "*").

      • from (number): Start time in epoch seconds.

      • to (number): End time in epoch seconds.

      • groupBy (optional string): Dimension to group results by (default: "application.name").

    • Returns: Grouped event counts.

  10. get_rum_page_performance

    • Get page (view) performance metrics from RUM data.

    • Inputs:

      • query (optional string): Additional query filter for RUM search (default: "*").

      • from (number): Start time in epoch seconds.

      • to (number): End time in epoch seconds.

      • metricNames (array of strings): Array of metric names to retrieve (e.g., 'view.load_time', 'view.first_contentful_paint').

    • Returns: Performance metrics including average, min, max, and count for each metric.

  11. get_rum_page_waterfall

    • Retrieve RUM page (view) waterfall data filtered by application name and session ID.

    • Inputs:

      • applicationName (string): Application name to filter events.

      • sessionId (string): Session ID to filter events.

    • Returns: Waterfall data for the specified application and session.

Setup

Datadog Credentials

You need valid Datadog API credentials to use this MCP server:

  • DATADOG_API_KEY: Your Datadog API key

  • DATADOG_APP_KEY: Your Datadog Application key

  • DATADOG_SITE (optional): The Datadog site (e.g. datadoghq.eu)

Export them in your environment before running the server:

export DATADOG_API_KEY="your_api_key"
export DATADOG_APP_KEY="your_app_key"
export DATADOG_SITE="your_datadog_site"

Installation

Installing via Smithery

To install Datadog MCP Server for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install @winor30/mcp-server-datadog --client claude

Manual Installation

pnpm install
pnpm build
pnpm watch   # for development with auto-rebuild

Usage with Claude Desktop

To use this with Claude Desktop, add the following to your claude_desktop_config.json:

On MacOS: ~/Library/Application Support/Claude/claude_desktop_config.json On Windows: %APPDATA%/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
      }
    }
  }
}
{
  "mcpServers": {
    "datadog": {
      "command": "/path/to/mcp-server-datadog/build/index.js",
      "env": {
        "DATADOG_API_KEY": "<YOUR_API_KEY>",
        "DATADOG_APP_KEY": "<YOUR_APP_KEY>",
        "DATADOG_SITE": "<YOUR_SITE>" // Optional
      }
    }
  }
}

Or specify via npx:

{
  "mcpServers": {
    "mcp-server-datadog": {
      "command": "npx",
      "args": ["-y", "@winor30/mcp-server-datadog"],
      "env": {
        "DATADOG_API_KEY": "<YOUR_API_KEY>",
        "DATADOG_APP_KEY": "<YOUR_APP_KEY>",
        "DATADOG_SITE": "<YOUR_SITE>" // Optional
      }
    }
  }
}

Debugging

Because MCP servers communicate over standard input/output, debugging can sometimes be tricky. We recommend using the MCP Inspector. You can run the inspector with:

npm run inspector

The inspector will provide a URL you can open in your browser to see logs and send requests manually.

Contributing

Contributions are welcome! Feel free to open an issue or a pull request if you have any suggestions, bug reports, or improvements to propose.

License

This project is licensed under the Apache License, Version 2.0.

Available Tools

13 tools
get_dashboardC

Get a dashboard from Datadog

Inputs: dashboardId (required).

get_incidentC

Get an incident from Datadog

Inputs: incidentId (required).

get_monitorsC

Get monitors status from Datadog

Inputs: groupStates, name, tags.

get_rum_applicationsB

Get all RUM applications in the organization

Inputs: no named parameters.

get_rum_eventsC

Search and retrieve RUM events from Datadog

Inputs: from (required), to (required), query, limit.

get_rum_grouped_event_countC

Search, group and count RUM events by a specified dimension

Inputs: from (required), to (required), query, groupBy.

get_rum_page_performanceC

Get page (view) performance metrics from RUM data

Inputs: from (required), to (required), query, metricNames.

get_rum_page_waterfallB

Retrieve RUM page (view) waterfall data filtered by application name and session ID

Inputs: applicationName (required), sessionId (required).

list_dashboardsC

Get list of dashboards from Datadog

Inputs: name, tags.

list_incidentsC

Get incidents from Datadog

Inputs: pageSize, pageOffset.

list_metricsC

List active metric names from Datadog

Inputs: from, tagFilter.

list_spansC

Get a list of spans matching a search query

Inputs: from (required), to (required), query, sort, +2 more.

query_metricsC

Query timeseries points of metrics from Datadog

Inputs: from (required), to (required), query (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 13 tools

    Disambiguation4/5

    Most tools have distinct purposes targeting specific Datadog resources like dashboards, incidents, monitors, RUM, metrics, and spans. However, there is some potential overlap between 'get_rum_events' and 'get_rum_grouped_event_count' as both involve retrieving RUM events, though the latter adds grouping and counting functionality. Overall, the descriptions help clarify differences, but a few tools could be slightly confusing without careful reading.

    Naming Consistency5/5

    The naming is highly consistent, following a clear verb_noun pattern throughout. All tools use either 'get_' or 'list_' prefixes followed by a specific resource name, with no deviations in style or convention. This predictability makes it easy for agents to understand and select tools based on their intended actions.

    Tool Count5/5

    With 13 tools, the count is well-scoped for a Datadog monitoring and observability server. It covers key areas like dashboards, incidents, monitors, RUM, metrics, and spans without being overwhelming. Each tool appears to serve a distinct purpose, contributing to a comprehensive toolset that aligns with the server's domain.

    Completeness4/5

    The toolset provides strong read-only coverage for Datadog's core features, including retrieval and listing of dashboards, incidents, monitors, RUM data, metrics, and spans. However, there are notable gaps in write operations (e.g., no create, update, or delete tools) and limited query capabilities beyond basic metrics and RUM events. Agents can work around this for read-heavy tasks, but full lifecycle management is not supported.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to interact with DataDog's observability platform through a standardized interface. Supports monitoring infrastructure, managing events, analyzing logs and metrics, and automating operations like alerts and downtimes.
      1
      MIT
    • A
      license
      C
      quality
      C
      maintenance
      Enables interaction with Datadog APIs through automatically generated tools from Postman collections. Supports monitoring operations, log management, metrics submission, and other Datadog functionality through natural language.
      100
      17 npm
      Apache 2.0
    • F
      license
      B
      quality
      F
      maintenance
      Enables comprehensive Datadog monitoring capabilities including CI/CD pipeline management, service logs analysis, metrics querying, monitor and SLO management, service definitions retrieval, and team management through Claude and other MCP clients.
      13
      20
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol (MCP) server that provides comprehensive Datadog monitoring capabilities, enabling Claude to manage CI/CD pipelines, analyze logs, query metrics, and handle monitors and SLOs.
      -