Try Bifrost Enterprise free for 14 days. Request access

Datadog MCP Server: Setup, Toolsets, and Governed Access for AI Agents

The Datadog MCP server lets AI agents query logs, metrics, traces, monitors, and incidents. This guide covers Datadog MCP setup, toolsets, and auth, and how to route the server through Bifrost so every client gets scoped tools, managed credentials, and one log of tool calls.

Datadog MCP Server: Setup, Toolsets, and Governed Access for AI Agents

TL;DR

  • The Datadog MCP server is a remote MCP endpoint that lets AI clients and agents query Datadog logs, metrics, traces, monitors, incidents, dashboards, and more.
  • It exposes a core toolset by default and dozens of optional product toolsets, selected with a toolsets query parameter or the X-Datadog-MCP-Toolsets header.
  • It authenticates with OAuth or with DD_API_KEY and DD_APPLICATION_KEY headers, so access follows the permissions of the user or keys behind each connection.
  • Connecting every AI client directly spreads keys and full tool access across laptops and agents, with no single record of which tool was called.
  • Routing the Datadog MCP server through Bifrost centralizes credentials, filters tools per team or agent, and logs every call; the Bifrost Datadog plugin also sends gateway traces and LLM Observability data back to Datadog.

The Datadog MCP server gives AI coding assistants and agents direct access to production telemetry, which makes it one of the most useful MCP servers for engineering teams and one of the most sensitive. Bifrost, the open-source AI gateway built by Maxim AI, sits between AI clients and the Datadog MCP server so teams can decide which tools each agent sees and keep a record of every call. This guide covers Datadog MCP setup, toolsets, authentication, and a governed rollout through Bifrost.

What Is the Datadog MCP Server?

The Datadog MCP server is a Datadog-managed, remote Model Context Protocol server that exposes Datadog data and actions as tools for AI clients. An agent connected to it can search logs, pull metrics, read traces, list monitors and incidents, and work with notebooks and dashboards, all through natural-language requests that the model turns into tool calls.

Typical Datadog MCP uses:

  • Incident triage. Ask an agent to pull recent error logs, related traces, and the monitors that fired for a service.
  • Debugging from the editor. A coding agent in Claude Code or Cursor checks production errors for the function it is changing.
  • Reporting. Summarize SLO status or incident timelines into a notebook.
  • On-call assistants. Internal agents answer "what changed?" questions across metrics, events, and deployments.

Datadog publishes setup instructions for the MCP server for Claude, ChatGPT, Codex, Cursor, VS Code, and other clients.

The Bifrost MCP server directory lists setup guides for other servers teams often pair with it, such as GitHub and Sentry.

Datadog MCP Toolsets and Tools

The Datadog MCP server organizes its tools into toolsets. Only the core toolset is enabled by default, covering logs, metrics, traces, dashboards, monitors, incidents, hosts, services, events, and notebooks. Product toolsets such as APM, Alerting, Security, Database Monitoring, Synthetics, and Cloud Cost Management are added by naming them in the connection.

The Datadog MCP tools reference lists more than 400 tools across these toolsets. A few examples from the core set:

Tool What it does Access type
search_datadog_logs Searches logs with a query and time range Read
get_datadog_metric Retrieves metric time series Read
get_datadog_trace Fetches a distributed trace Read
search_datadog_monitors Lists monitors and their status Read
search_datadog_incidents Lists incidents Read
create_datadog_notebook Creates a notebook Write
delete_datadog_notebook Deletes a notebook Write

Toolsets are selected in two ways:

  • Query parameter. Append ?toolsets=apm,llmobs to the endpoint URL, or ?toolsets=all for every generally available toolset.
  • Header. Send X-Datadog-MCP-Toolsets: apm,llmobs on the connection.

Enabling all gives agents the widest reach but also the largest tool list, which costs context and makes tool selection harder. The guide to how MCP tools work explains why large tool lists matter.

How Datadog MCP Authentication Works

The Datadog MCP server supports two authentication methods: an OAuth login flow, where each user signs in to Datadog in a browser, and API key authentication, where the client sends a Datadog API key and application key as DD_API_KEY and DD_APPLICATION_KEY headers. Either way, tool calls run with the Datadog permissions of the signed-in user or the keys provided.

Practical implications:

  • Pick the right site. Each Datadog site has its own endpoint, such as https://mcp.datadoghq.com/v1/mcp for US1 and https://mcp.datadoghq.eu/v1/mcp for EU.
  • Application keys carry permissions. An application key acts with the permissions of the user or service account that created it, so a key from an admin account gives agents admin reach.
  • Keys sprawl quickly. If every developer pastes keys into their own client config, revoking or rotating access means finding every copy.

Datadog documents API and application keys and their scopes. Teams that want each engineer to keep their own Datadog identity, without storing keys on laptops, can use per-user credentials at the gateway; the Bifrost MCP authentication overview lists every option.

Direct Connections vs a Gateway

Connecting each AI client directly to the Datadog MCP server is the fastest way to start, but it scales poorly. Every client holds its own keys, sees whatever toolsets it enabled, and logs nothing centrally. Routing through a gateway such as Bifrost keeps one connection to Datadog, scopes tools per team or agent, and records every call.

Figure 1 compares the two setups.

Top: Claude Code, Cursor, and agents each connect straight to the Datadog MCP server with their own keys. Bottom: all clients connect through Bifrost, which holds credentials and filters tools

Top: Claude Code, Cursor, and agents each connect straight to the Datadog MCP server with their own keys. Bottom: all clients connect through Bifrost, which holds credentials and filters tools

Figure 1: Direct connections spread Datadog keys and tool access across every client; routing through a gateway keeps credentials, tool filtering, and logs in one place.

Concern Direct connection Through Bifrost
Credentials Keys in each client config Held in Bifrost (encrypted at rest with an encryption key set) or supplied per user
Tool access Whatever toolsets each client enables Filtered per MCP client, per request, and per virtual key
Write tools Available if the key allows them Can be removed from the tool list entirely
Audit trail Spread across clients, if kept at all Every tool call logged alongside the model request that produced it
Rotation Update every client Update once in Bifrost

The comparison of MCP gateways vs MCP proxies vs MCP servers covers the architecture, and the risks of ungoverned MCP server access covers what goes wrong without one.

How to Connect the Datadog MCP Server to Bifrost

Connecting the Datadog MCP server to Bifrost takes five steps: pick the endpoint and toolsets, choose an authentication model, register the server as an HTTP MCP client, filter its tools, and attach it to the virtual keys your clients use. After that, every AI client reaches Datadog through the Bifrost MCP gateway instead of connecting on its own.

Five steps in a row: pick the Datadog site endpoint, choose an auth model, register the server in Bifrost, filter tools, then attach it to virtual keys for clients

Five steps in a row: pick the Datadog site endpoint, choose an auth model, register the server in Bifrost, filter tools, then attach it to virtual keys for clients

Figure 2: Five steps take the Datadog MCP server from a raw endpoint to a governed tool set that every AI client reaches through Bifrost.

Step 1: Pick the endpoint and toolsets

Use the endpoint for your Datadog site and add only the toolsets your use case needs. For an incident-triage agent, core plus APM is a sensible start:

<https://mcp.datadoghq.com/v1/mcp?toolsets=core,apm>

Step 2: Choose an authentication model

Bifrost supports several upstream authentication modes for MCP servers. Two fit Datadog well:

  • Shared service account. Header authentication attaches one set of Datadog keys to every call. Create the keys on a read-only service account so the scope is explicit.
  • Per-engineer keys. Per-user headers let each user submit their own DD_API_KEY and DD_APPLICATION_KEY, stored encrypted per identity, so tool calls keep each person's Datadog permissions.

Step 3: Register the server in Bifrost

Add the Datadog MCP server as an HTTP client through the Bifrost dashboard (MCP Gateway, then New MCP Server) or the API. With shared headers, the values reference environment variables so keys stay out of config files:

curl -X POST <http://localhost:8080/api/mcp/client> \
  -H "Content-Type: application/json" \
  -d '{
    "name": "datadog",
    "connection_type": "http",
    "connection_string": "<https://mcp.datadoghq.com/v1/mcp?toolsets=core,apm>",
    "auth_type": "headers",
    "headers": {
      "DD_API_KEY": "env.DD_API_KEY",
      "DD_APPLICATION_KEY": "env.DD_APPLICATION_KEY"
    },
    "tools_to_execute": ["*"]
  }'

The MCP server connection guide covers the other connection options, including session stickiness for HTTP clients.

Step 4: Filter the tools

Replace the * in tools_to_execute with an explicit list, starting read-only:

"tools_to_execute": [
  "search_datadog_logs",
  "get_datadog_metric",
  "get_datadog_trace",
  "search_datadog_monitors",
  "search_datadog_incidents"
]

Tool filtering also applies per request and per virtual key, and a tool must pass every applicable filter to be visible.

Step 5: Attach it to virtual keys and connect clients

Give each team or agent a virtual key with the Datadog tools it needs, or bundle Datadog tools with other servers in a Virtual MCP served at its own /mcp/<slug> endpoint. Clients then connect to Bifrost, for example from Claude Code:

claude mcp add --transport http bifrost <https://bifrost.example.com/mcp> \
  --header "x-bf-vk: sk-bf-your-virtual-key"

Gateway authentication also supports browser-based OAuth 2.1 for interactive clients.

Governing Datadog MCP Access

Governing Datadog MCP access means deciding which agents can read which data, keeping write actions behind deliberate approval, and being able to show what every agent did. Production telemetry often contains customer identifiers, internal hostnames, and sometimes secrets in log lines, so the defaults matter.

Controls to set in Bifrost:

  • Read-only by default. Expose search and get tools; add create, edit, and delete tools only for agents that need them.
  • Scope by team. An SRE agent can see APM and incident tools; a coding agent may only need logs and traces for its own services.
  • Explicit execution. Tool calls from models are suggestions by default, and agent mode auto-execution has to be configured per tool.
  • Role-based administration. RBAC and access profiles in Bifrost Enterprise control who can change MCP servers, keys, and policies.

Content checks on tool traffic:

  • Secrets in results. Secrets detection can flag or redact credentials that appear in log lines returned to the model.
  • MCP guardrails. The post on MCP guardrails in Bifrost covers rules that run on tool inputs and outputs.

The guide to MCP server governance best practices covers policy design across servers.

Sending Bifrost Telemetry Back to Datadog

Datadog also works in the other direction. The Bifrost Datadog plugin sends gateway telemetry into Datadog, so the same platform that agents query through the MCP server also records every model and tool request the gateway handles. Teams get Datadog MCP access for agents and Datadog visibility into the agents themselves.

Agents query Datadog through Bifrost and the Datadog MCP server, while the Bifrost Datadog plugin sends APM traces, LLM Observability spans, and metrics back into Datadog

Agents query Datadog through Bifrost and the Datadog MCP server, while the Bifrost Datadog plugin sends APM traces, LLM Observability spans, and metrics back into Datadog

Figure 3: Agents read from Datadog through the MCP server, and the Datadog plugin writes gateway traces and LLM Observability data back, so the same platform sees both sides.

What the Bifrost Datadog integration sends:

  • APM traces through dd-trace-go v2, with W3C Trace Context for end-to-end request visibility.
  • LLM Observability spans through the native Datadog LLM Observability integration.
  • Metrics through DogStatsD or the Datadog Metrics API.

It runs in agent mode, through a local Datadog Agent, or agentless mode, sending directly to Datadog APIs with an API key. Options such as disable_content_logging drop message content from exported spans when payloads should not leave the gateway. Teams on other stacks can use OpenTelemetry export instead.

Auditing Datadog Tool Calls

Every Datadog tool call that passes through Bifrost is logged with the model request that produced it, the virtual key that made it, and the result. That record answers the questions security and platform teams ask after an incident: which agent queried which data, when, and on whose behalf.

What the record supports:

  • Investigations. Trace a surprising notebook edit or monitor change back to the agent and user.
  • Access reviews. See which teams actually use which Datadog tools before widening or narrowing scopes.
  • Cost attribution. Tool calls sit next to the token cost of the model calls that triggered them.

Bifrost request logs hold the per-request data, and audit logs track administrative changes such as adding a server or editing a tool filter.

The guide to auditing every AI tool call and the post on MCP audit logging requirements cover retention and compliance.

Datadog MCP Best Practices

A Datadog MCP rollout goes well when access starts narrow and widens with evidence. The same few practices apply whether the first users are a handful of SREs in Claude Code or a fleet of internal agents.

  • Start with core and add product toolsets only when a use case needs them.
  • Use a dedicated service account with read-only permissions for shared keys.
  • Keep keys out of client configs; store them in Bifrost as environment-variable references or use per-user headers.
  • Separate read and write. Put write tools on a different virtual key or Virtual MCP that only specific agents receive.
  • Review usage monthly from tool-call logs and remove tools nobody uses.
  • Watch context size. Large toolsets inflate prompts; Code Mode keeps tool definitions out of context for multi-step work.

For more on running many servers side by side, see remote MCP server gateways and the Atlassian MCP server guide.

Frequently Asked Questions

What is the Datadog MCP server?

The Datadog MCP server is a remote MCP endpoint managed by Datadog that exposes logs, metrics, traces, monitors, incidents, dashboards, notebooks, and product-specific data as tools for AI clients and agents. Clients such as Claude Code, Cursor, and custom agents connect to it with OAuth or API and application keys.

How do I set up Datadog MCP in Claude Code?

You can add the Datadog endpoint for your site directly in Claude Code, or connect Claude Code to Bifrost with a virtual key and let Bifrost hold the Datadog connection. The second option keeps keys off developer machines and applies per-key tool filters and logging to every call.

What toolsets does the Datadog MCP server support?

The core toolset is enabled by default and covers logs, metrics, traces, dashboards, monitors, incidents, hosts, services, events, and notebooks. Product toolsets, including APM, Alerting, Security, Database Monitoring, Synthetics, and Cloud Cost Management, are added with the toolsets query parameter or the X-Datadog-MCP-Toolsets header.

Is the Datadog MCP server safe for production data?

It runs with the permissions of the user or keys behind each connection, so safety depends on scoping. Use read-only service accounts, enable only needed toolsets, keep write tools separate, and log every call. A gateway such as Bifrost centralizes those controls.

Can each engineer use their own Datadog permissions through Bifrost?

Yes. With per-user headers, each user submits their own Datadog API and application keys once, Bifrost stores them encrypted per identity, and tool calls run with that user's Datadog permissions. The per-user headers guide covers setup.

Does Bifrost send data to Datadog?

Yes, if you enable the Datadog plugin. It sends APM traces, LLM Observability spans, and metrics for requests that pass through Bifrost, in agent or agentless mode, with options to drop message content from exported spans.

Give Agents Datadog Access Without Losing Control

The Datadog MCP server puts production telemetry in reach of every AI client, which is exactly why access should run through one governed path. Bifrost holds the Datadog connection, filters tools per team and agent, logs every call, and sends gateway telemetry back to Datadog. To see it with your observability stack, book a demo with the Bifrost team.