SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Datadog MCP with Vercel AI SDK v6

Connect Vercel AI SDK v6 to Datadog MCP. Create downtime for nightly maintenance window, list all monitors tracking cpu usage, and more using natural language, with authentication handled for you.

Get started for freeGet a demo
Datadog logoDatadog
Oauth2Api KeyBearer Token

Datadog is a cloud monitoring and observability platform for applications and infrastructure. It helps teams detect issues and optimize performance by unifying metrics, logs, and traces.

248 Tools

Introduction

This guide walks you through connecting Datadog to Vercel AI SDK v6 using the Composio tool router. By the end, you'll have a working Datadog agent that can search logs, query metrics, create and mute monitors, build dashboards, and manage SLOs and downtimes through natural language commands.

This guide will help you understand how to give your Vercel AI SDK agent real control over a Datadog account through Composio's Datadog MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Datadog with

Claude CodeCursorChatGPTClaude CoworkAntigravityOpenAI Agents SDKClaude Agent SDKCodexKimi CodeGrok BuildVS CodeOpenCodeOpenClawHermesAtomic AgentPiDeepSeek HarnessCLIGoogle ADKLangChainMastra AILlamaIndexCrewAIPydantic AIAutoGen

TL;DR

Here's what you'll learn:
  • How to set up and configure a Vercel AI SDK agent with Datadog integration
  • Using Composio's Tool Router to dynamically load and access Datadog tools
  • Creating an MCP client connection using HTTP transport
  • Building an interactive CLI chat interface with conversation history management
  • Handling tool calls and results within the Vercel AI SDK framework

What is Vercel AI SDK?

The Vercel AI SDK is a TypeScript library for building AI-powered applications. It provides tools for creating agents that can use external services and maintain conversation state.

Key features include:

  • streamText: Core function for streaming responses with real-time tool support
  • MCP Client: Built-in support for Model Context Protocol via @ai-sdk/mcp
  • Step Counting: Control multi-step tool execution with stopWhen: stepCountIs()
  • OpenAI Provider: Native integration with OpenAI models

What is the Datadog MCP server, and what's possible with it?

The Datadog MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Datadog account. It provides structured and secure access to your monitoring and observability platform, so your agent can perform actions like creating dashboards, managing monitors, scheduling downtimes, and tracking key events on your behalf.

  • Custom dashboard creation and management: Direct your agent to build new dashboards or retrieve detailed information about existing dashboards for unified infrastructure and application monitoring.
  • Monitor setup and deletion: Easily have your agent create new monitors to track critical metrics or remove outdated ones to keep your alerting system relevant.
  • Automated downtime scheduling: Let your agent schedule maintenance windows by creating downtimes that suppress alerts during planned outages or deployments.
  • Event tracking and logging: Ask your agent to create and log significant events—like deployments or configuration changes—so your team always stays informed.
  • Service level objectives and synthetic testing: Instruct your agent to define SLOs or set up synthetic API tests for continuous reliability and performance tracking.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before you begin, make sure you have:
  • Node.js and npm installed
  • A Composio account with API key
  • An OpenAI API key
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key. You'll need credits to use the models, or you can connect to another model provider.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install required dependencies

bash
npm install @ai-sdk/openai @ai-sdk/mcp @composio/core ai dotenv

First, install the necessary packages for your project.

What you're installing:

  • @ai-sdk/openai: Vercel AI SDK's OpenAI provider
  • @ai-sdk/mcp: MCP client for Vercel AI SDK
  • @composio/core: Composio SDK for tool integration
  • ai: Core Vercel AI SDK
  • dotenv: Environment variable management
4

Set up environment variables

bash
OPENAI_API_KEY=your_openai_api_key_here
COMPOSIO_API_KEY=your_composio_api_key_here
COMPOSIO_USER_ID=your_user_id_here

Create a .env file in your project root.

What's needed:

  • OPENAI_API_KEY: Your OpenAI API key for GPT model access
  • COMPOSIO_API_KEY: Your Composio API key for tool access
  • COMPOSIO_USER_ID: A unique identifier for the user session
5

Import required modules and validate environment

typescript
import "dotenv/config";
import { openai } from "@ai-sdk/openai";
import { Composio } from "@composio/core";
import * as readline from "readline";
import { streamText, type ModelMessage, stepCountIs } from "ai";
import { createMCPClient } from "@ai-sdk/mcp";

const composioAPIKey = process.env.COMPOSIO_API_KEY;
const composioUserID = process.env.COMPOSIO_USER_ID;

if (!process.env.OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set");
if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set");

const composio = new Composio({
  apiKey: composioAPIKey,
});
What's happening:
  • We're importing all necessary libraries including Vercel AI SDK's OpenAI provider and Composio
  • The dotenv/config import automatically loads environment variables
  • The MCP client import enables connection to Composio's tool server
6

Create Tool Router session and initialize MCP client

typescript
async function main() {
  // Create a tool router session for the user
  const session = await composio.create(composioUserID!, {
    toolkits: ["datadog"],
  });

  const mcpUrl = session.mcp.url;
What's happening:
  • We're creating a Tool Router session that gives your agent access to Datadog tools
  • The create method takes the user ID and specifies which toolkits should be available
  • The returned mcp object contains the URL and authentication headers needed to connect to the MCP server
  • This session provides access to all Datadog-related tools through the MCP protocol
7

Connect to MCP server and retrieve tools

typescript
const mcpClient = await createMCPClient({
  transport: {
    type: "http",
    url: mcpUrl,
    headers: session.mcp.headers, // Authentication headers for the Composio MCP server
  },
});

const tools = await mcpClient.tools();
What's happening:
  • We're creating an MCP client that connects to our Composio Tool Router session via HTTP
  • The mcp.url provides the endpoint, and mcp.headers contains authentication credentials
  • The type: "http" is important - Composio requires HTTP transport
  • tools() retrieves all available Datadog tools that the agent can use
8

Initialize conversation and CLI interface

typescript
let messages: ModelMessage[] = [];

console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
console.log(
  "Ask any questions related to datadog, like summarize my last 5 emails, send an email, etc... :)))\n",
);

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: "> ",
});

rl.prompt();
What's happening:
  • We initialize an empty messages array to maintain conversation history
  • A readline interface is created to accept user input from the command line
  • Instructions are displayed to guide the user on how to interact with the agent
9

Handle user input and stream responses with real-time tool feedback

typescript
rl.on("line", async (userInput: string) => {
  const trimmedInput = userInput.trim();

  if (["exit", "quit", "bye"].includes(trimmedInput.toLowerCase())) {
    console.log("\nGoodbye!");
    rl.close();
    process.exit(0);
  }

  if (!trimmedInput) {
    rl.prompt();
    return;
  }

  messages.push({ role: "user", content: trimmedInput });
  console.log("\nAgent is thinking...\n");

  try {
    const stream = streamText({
      model: openai("gpt-5"),
      messages,
      tools,
      toolChoice: "auto",
      stopWhen: stepCountIs(10),
      onStepFinish: (step) => {
        for (const toolCall of step.toolCalls) {
          console.log(`[Using tool: ${toolCall.toolName}]`);
          }
          if (step.toolCalls.length > 0) {
            console.log(""); // Add space after tool calls
          }
        },
      });

      for await (const chunk of stream.textStream) {
        process.stdout.write(chunk);
      }

      console.log("\n\n---\n");

      // Get final result for message history
      const response = await stream.response;
      if (response?.messages?.length) {
        messages.push(...response.messages);
      }
    } catch (error) {
      console.error("\nAn error occurred while talking to the agent:");
      console.error(error);
      console.log(
        "\nYou can try again or restart the app if it keeps happening.\n",
      );
    } finally {
      rl.prompt();
    }
  });

  rl.on("close", async () => {
    await mcpClient.close();
    console.log("\n👋 Session ended.");
    process.exit(0);
  });
}

main().catch((err) => {
  console.error("Fatal error:", err);
  process.exit(1);
});
What's happening:
  • We use streamText instead of generateText to stream responses in real-time
  • toolChoice: "auto" allows the model to decide when to use Datadog tools
  • stopWhen: stepCountIs(10) allows up to 10 steps for complex multi-tool operations
  • onStepFinish callback displays which tools are being used in real-time
  • We iterate through the text stream to create a typewriter effect as the agent responds
  • The complete response is added to conversation history to maintain context
  • Errors are caught and displayed with helpful retry suggestions

Complete Code

Here's the complete code to get you started with Datadog and Vercel AI SDK:

typescript
import "dotenv/config";
import { openai } from "@ai-sdk/openai";
import { Composio } from "@composio/core";
import * as readline from "readline";
import { streamText, type ModelMessage, stepCountIs } from "ai";
import { createMCPClient } from "@ai-sdk/mcp";

const composioAPIKey = process.env.COMPOSIO_API_KEY;
const composioUserID = process.env.COMPOSIO_USER_ID;

if (!process.env.OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set");
if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set");

const composio = new Composio({
  apiKey: composioAPIKey,
});

async function main() {
  // Create a tool router session for the user
  const session = await composio.create(composioUserID!, {
    toolkits: ["datadog"],
  });

  const mcpUrl = session.mcp.url;

  const mcpClient = await createMCPClient({
    transport: {
      type: "http",
      url: mcpUrl,
      headers: session.mcp.headers, // Authentication headers for the Composio MCP server
    },
  });

  const tools = await mcpClient.tools();

  let messages: ModelMessage[] = [];

  console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
  console.log(
    "Ask any questions related to datadog, like summarize my last 5 emails, send an email, etc... :)))\n",
  );

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: "> ",
  });

  rl.prompt();

  rl.on("line", async (userInput: string) => {
    const trimmedInput = userInput.trim();

    if (["exit", "quit", "bye"].includes(trimmedInput.toLowerCase())) {
      console.log("\nGoodbye!");
      rl.close();
      process.exit(0);
    }

    if (!trimmedInput) {
      rl.prompt();
      return;
    }

    messages.push({ role: "user", content: trimmedInput });
    console.log("\nAgent is thinking...\n");

    try {
      const stream = streamText({
        model: openai("gpt-5"),
        messages,
        tools,
        toolChoice: "auto",
        stopWhen: stepCountIs(10),
        onStepFinish: (step) => {
          for (const toolCall of step.toolCalls) {
            console.log(`[Using tool: ${toolCall.toolName}]`);
          }
          if (step.toolCalls.length > 0) {
            console.log(""); // Add space after tool calls
          }
        },
      });

      for await (const chunk of stream.textStream) {
        process.stdout.write(chunk);
      }

      console.log("\n\n---\n");

      // Get final result for message history
      const response = await stream.response;
      if (response?.messages?.length) {
        messages.push(...response.messages);
      }
    } catch (error) {
      console.error("\nAn error occurred while talking to the agent:");
      console.error(error);
      console.log(
        "\nYou can try again or restart the app if it keeps happening.\n",
      );
    } finally {
      rl.prompt();
    }
  });

  rl.on("close", async () => {
    await mcpClient.close();
    console.log("\n👋 Session ended.");
    process.exit(0);
  });
}

main().catch((err) => {
  console.error("Fatal error:", err);
  process.exit(1);
});

Conclusion

You've successfully built a Datadog agent using the Vercel AI SDK with streaming capabilities! This implementation provides a powerful foundation for building AI applications with natural language interfaces and real-time feedback.

Key features of this implementation:

  • Real-time streaming responses for a better user experience with typewriter effect
  • Live tool execution feedback showing which tools are being used as the agent works
  • Dynamic tool loading through Composio's Tool Router with secure authentication
  • Multi-step tool execution with configurable step limits (up to 10 steps)
  • Comprehensive error handling for robust agent execution
  • Conversation history maintenance for context-aware responses

You can extend this further by adding custom error handling, implementing specific business logic, or integrating additional Composio toolkits to create multi-app workflows.
TOOLS

Supported Tools

Every Datadog action and event your agent gets out of the box.

Abort a multipart upload of a test file

Abort a multipart upload of a test file.

Acknowledge On-Call Page

Acknowledge an On-Call page by ID via POST /api/v2/on-call/pages/{page_id}/acknowledge.

Add a test to a Synthetics downtime

Add a test to a Synthetics downtime.

Aggregate logs

Aggregate Datadog logs without downloading raw events for counts, unique-value counts, percentiles, numeric statistics, grouped breakdowns, and values over time.

Cancel a downtime

Cancel a downtime.

Check if a monitor can be deleted

Check if the given monitors can be deleted.

Check if SLOs can be safely deleted

Check if SLOs can be safely deleted without disrupting resources such as dashboards.

Complete a multipart upload of a test file

Complete a multipart upload of a test file.

Create an API test

Create an API test.

Create Dashboard

Create a dashboard in Datadog.

Create a dashboard list

Create a dashboard list.

Add Items to a Dashboard List

Add Items to a Dashboard List.

Create a derived metric

Create a derived metric.

Create downtime

Creates a new downtime in Datadog to suppress alerts during maintenance windows or planned outages.

Create On-Call escalation policy

Creates a Datadog On-Call escalation policy.

Create event

Creates a new event in Datadog.

Post an event

Post an event.

Create a global variable

Create a global variable.

Create graph snapshot

Create a hosted PNG snapshot from a metric query or graph definition.

Create an incident impact

Create an incident impact.

Create monitor

Creates a new Datadog monitor to track metrics, logs, or other data sources with configurable alerting thresholds and notifications.

Create a monitor configuration policy

Create a monitor configuration policy.

Create a monitor notification rule

Create a monitor notification rule.

Create a notebook

Create a notebook.

Create On-Call notification channel

Creates an On-Call notification channel for a Datadog user.

Create On-Call notification rule

Creates an On-Call notification rule for a Datadog user.

Create On-Call Page

Create a Datadog On-Call page to notify a target team or user about an issue.

Create or update service definition

Create or update service definition.

Create a shared dashboard

Create a shared dashboard.

Create On-Call schedule

Creates a Datadog On-Call schedule.

Create On-Call schedule overrides

Create On-Call schedule overrides.

Create SLO

Create a metric-based or monitor-based Service Level Objective (SLO) in Datadog to track service reliability targets.

Create Synthetic API Test

Create a synthetic API test in Datadog for proactive monitoring of API uptime, performance, and functionality.

Create a browser test

Create a browser test.

Create a Synthetics downtime

Create a Synthetics downtime.

Create a mobile test

Create a mobile test.

Create a Network Path test

Create a Network Path test.

Create a test suite

Create a test suite.

Create a tag configuration

Create a tag configuration.

Create Webhook

Create a webhook in Datadog.

Delete a single entity

Delete a single entity.

Delete a single kind

Delete a single kind.

Delete Dashboard

Delete a dashboard in Datadog.

Delete a dashboard list

Delete a dashboard list.

Delete items from a dashboard list

Delete items from a dashboard list.

Delete dashboards

Delete dashboards by ID, atomically: any failure prevents all deletions.

Delete a derived metric

Delete a derived metric.

Delete On-Call escalation policy

Deletes a Datadog On-Call escalation policy by ID.

Delete a global variable

Delete a global variable.

Delete an incident impact

Delete an incident impact.

Delete monitor

Deletes a Datadog monitor permanently.

Delete a monitor configuration policy

Delete a monitor configuration policy.

Delete a monitor notification rule

Delete a monitor notification rule.

Delete a notebook

Delete a notebook.

Delete On-Call notification channel

Deletes an On-Call notification channel for a Datadog user.

Delete On-Call notification rule

Deletes an On-Call notification rule for a Datadog user.

Delete a private location

Delete a private location.

Revoke a shared dashboard URL

Revoke a shared dashboard URL.

Revoke shared dashboard invitations

Revoke shared dashboard invitations.

Delete On-Call schedule

Deletes a Datadog On-Call schedule by ID.

Delete On-Call schedule override

Delete On-Call schedule override.

Delete a single service definition

Delete a single service definition.

Delete an SLO

Delete an SLO.

Bulk Delete SLO Timeframes

Delete thresholds from multiple SLOs using a mapping of SLO IDs to timeframes; deleting all thresholds also deletes the SLO.

Delete a Synthetics downtime

Delete a Synthetics downtime.

Bulk delete suites

Bulk delete suites.

Bulk delete tests

Bulk delete tests.

Delete a tag configuration

Delete a tag configuration.

Delete tests

Delete tests.

Edit a global variable

Edit a global variable.

Edit a test suite

Edit a test suite.

Escalate On-Call Page

Escalate a Datadog On-Call page identified by its page ID.

Tag Configuration Cardinality Estimator

Tag Configuration Cardinality Estimator.

Fetch uptime for multiple tests

Fetch uptime for multiple tests.

Get parent tests for a subtest

Get API multistep tests that include a given subtest, along with their monitor status.

Get available subtests for a multistep test

Get API tests available as subtests for an API multistep test, excluding the current test.

Get an API test

Get the detailed configuration of a Synthetic API test by its public ID.

Get an API test's latest results summaries

Get an API test's latest results summaries.

Get an API test result

Get an API test result.

Get a browser test

Get the detailed configuration (including steps) of a Synthetic browser test.

Get a browser test's latest results summaries

Get the last 150 result summaries for a Synthetic browser test.

Get a browser test result

Get a specific full result from a Synthetic browser test.

Get Custom Evaluator Configuration

Retrieve one custom Agent Observability evaluator configuration by name.

Get Dashboard

Get a specific dashboard from Datadog.

Get a dashboard list

Fetch an existing dashboard list definition by ID.

Get items of a Dashboard List

Fetch the dashboard definitions in a dashboard list.

Get a derived metric

Get the definition of a derived metric by name.

Get a downtime

Get downtime detail by downtime_id.

Get On-Call escalation policy

Retrieves a Datadog On-Call escalation policy by ID.

Get an event

Get event details by event ID using GET /api/v1/events/{event_id}.

Get an event

Get the details of an event by event_id.

Get a global variable

Get a Synthetics global variable by ID using GET /api/v1/synthetics/variables/{variable_id}.

Get hourly usage

Gets hourly Datadog usage records for product families and a UTC hour range.

Get metric metadata

Get metadata for a specific metric using GET /api/v1/metrics/{metric_name}.

Get tag key cardinality details

Get tag key cardinality details for a specific metric.

Get a mobile test

Get the detailed configuration of a Synthetic mobile test.

Get monitor

Retrieves detailed information about a specific Datadog monitor, including its current state, configuration, and any active downtimes.

Get a monitor configuration policy

Get a monitor configuration policy by policy_id.

Get a monitor notification rule

Get a monitor notification rule by rule_id.

Get all monitor notification rules

Get all monitor notification rules.

Get a notebook

Get a notebook using its notebook ID.

Get On-Call notification channel

Retrieves an On-Call notification channel for a user by ID.

Get On-Call notification rule

Retrieves an On-Call notification rule for a user by ID.

Get the on-demand concurrency cap

Get the on-demand concurrency cap.

Get a private location

Get a Synthetic private location by its ID.

Get a shared dashboard

Fetch sharing metadata for an existing shared dashboard by its sharing token.

Get all invitations for a shared dashboard

Get all invitations for a shared dashboard.

Get On-Call schedule

Retrieves a Datadog On-Call schedule by ID.

Get scheduled on-call user

Gets the currently scheduled on-call user for a Datadog On-Call schedule using a deprecated Datadog endpoint.

Get on-call responders for a schedule

Get on-call responders for a schedule.

Get a single service definition

Get a single service definition by service name, optionally selecting the response schema version.

Get Service Dependencies

Get service dependency mapping from Datadog APM for a specific service, with upstream and downstream lists.

Get an SLO's details

Get a service level objective's details by ID.

Get Corrections For an SLO

Get corrections applied to an SLO.

Get an SLO's history

Get an SLO's history for an epoch-second time window, for metric, monitor, or time-slice SLOs.

Get a browser test result

Get a specific full result from a given Synthetic browser test.

Get details of batch

Get updated details of a batch.

Get the default locations

Get the default locations settings.

Get a Synthetics downtime

Get a Synthetics downtime by its ID.

Get a fast test result

Read a newly triggered Synthetic result by result ID, without needing a test public ID.

Get Synthetics Locations

Tool to retrieve all available public and private locations for Synthetic tests in Datadog.

Get a Network Path test

Get a Network Path test by its public ID.

Get a suite

Get a Synthetics suite by its public ID.

Get a test result

Get a specific full result from a given Synthetic test.

Get a specific version of a test

Get a specific version of a Synthetic test by its version number.

Get host tags

Retrieves tags associated with a specific host in Datadog, optionally filtered by tag source.

Get team on-call users

Gets the current on-call users for a Datadog On-Call team.

Get On-Call team routing rules

Gets the Datadog On-Call routing rules configured for a team.

Get a test configuration

Get the detailed configuration associated with a Synthetic test.

Get a presigned URL for downloading a test file

Get a presigned URL for downloading a test file.

Get presigned URLs for uploading a test file

Initiate a multipart test-file upload and return a presigned URL per part.

Get parent suites for a test

Get parent suites and their status for a Synthetic test.

Get usage summary

Retrieves usage summary information from Datadog including API calls, hosts, containers, and other billable usage metrics.

Get user

Retrieve one Datadog organization user by ID, including related resources.

Get a webhook integration

Get the content of a webhook integration by name.

List active tags and aggregations

List tags and aggregations actively queried for a metric on dashboards, notebooks, monitors, the Metrics Explorer, and the API.

List All Tags

List Datadog host tags, optionally filtered by source.

List API Keys

List a page of Datadog API keys for security auditing, access management, and key rotation planning.

List APM Services

List Datadog APM services, optionally filtering by environment.

List all AWS integrations

List all AWS integrations.

List AWS Integration

List AWS integrations in Datadog.

Get a list of entities

Get a list of entities.

Get a list of entity kinds

Get a list of entity kinds.

Get a list of entity relations

Get a list of entity relations.

Get all dashboard lists

Fetch all existing dashboard list definitions.

List dashboards

Lists Datadog dashboards with basic information, with optional shared and deleted filters and pagination.

Get all downtimes

Get all downtimes.

List events

Lists a page of Datadog events within a specified time range, with optional filters including tags, sources, and priority.

Get a list of events

Get a list of events.

Get all global variables

Get all Synthetic global variables.

List hosts

Lists a page of hosts in your Datadog infrastructure, with available metrics, tags, and status.

List an incident's impacts

List all impacts for an incident.

List Incidents

List a page of incidents from Datadog, with optional filtering and sorting.

List Log Indexes

Tool to retrieve a list of all log indexes configured in Datadog, including their names and configurations.

Search logs (GET)

Search logs (GET).

Related Assets to a Metric

Returns dashboards, monitors, notebooks, and SLOs containing a metric.

List active metrics

Discover metric names by listing actively reporting metrics since a given timestamp.

Get a list of metrics

Get a list of metrics using GET /api/v2/metrics, with optional pagination; when enabled, each call returns one page and pagination fields can be used to continue.

List metric tags

List indexed and ingested tags observed for one Datadog metric.

Get all monitor configuration policies

Get all monitor configuration policies.

Get active downtimes for a monitor

Get active downtimes for a monitor.

List monitors

List monitor details for your organization, with name and tag filters, group-state options, and pagination.

Get all notebooks

Get all notebooks.

List On-Call notification channels

Lists the On-Call notification channels configured for a Datadog user.

List On-Call notification rules

Lists the On-Call notification rules configured for a Datadog user.

List On-Call schedules

List On-Call schedules.

List Organizations

List top-level Datadog organization metadata visible to the account.

List Roles

List roles from Datadog organization.

List On-Call schedule overrides

List On-Call schedule overrides.

List service checks

Lists service checks from Datadog.

List service definitions

Page through service definitions in the Datadog Service Catalog.

List SLOs

List Service Level Objectives (SLOs) from Datadog.

List span-based metrics

List configured Datadog span-based metrics and their definitions.

Search spans

Search spans.

List Synthetics Tests

List Synthetics tests from Datadog, with optional tag and location filters and pagination parameters.

Get a browser test's latest results

Get a browser test's latest result summaries using GET /api/v2/synthetics/tests/browser/{public_id}/results.

List Synthetics downtimes

List Synthetics downtimes for your organization.

Get a test's latest results

Get the latest result summaries for a Synthetic test.

Get version history of a test

Get version history of a test.

List tag configuration by name

Return the tag configuration for a metric name using GET /api/v2/metrics/{metric_name}/tags.

List Users

List users from Datadog organization.

List distinct metric volumes by metric name

View hourly average cardinality for a metric over a look back period.

List Webhooks

List webhooks from Datadog for notification integrations.

Mute Monitor

Mute a monitor in Datadog.

Patch a global variable

Patch a global variable.

Patch a Synthetic test

Patch a Synthetic test.

Patch a test suite

Patch a test suite.

Poll for test results

Poll for test results given a JSON-encoded array of result IDs, typically after triggering tests with CI/CD.

Preview catalog entities

Preview catalog entities.

Query metrics

Queries Datadog metrics and returns time series data for a time range of up to 365 days.

Query scalar data

Run Datadog formula queries and return aggregated scalar columns.

Query timeseries data

Runs Datadog multi-product formula queries and returns aligned timeseries values.

Remove a test from a Synthetics downtime

Remove a test from a Synthetics downtime.

Resolve On-Call Page

Resolve an On-Call page by ID using POST /api/v2/on-call/pages/{page_id}/resolve.

Restore deleted dashboards

Restore deleted dashboards.

Schedule downtime

Schedule a Datadog v2 downtime to suppress monitor alerts, once or on an RRULE recurrence.

Search audit logs

Search Datadog Audit Trail events with filters and cursor pagination.

Search events

Searches Datadog Event Management events with filters and pagination.

Search logs

Searches Datadog logs using a query and a time range of up to 15 days, with optional index, limit, and pagination cursor; times are Unix timestamps in milliseconds.

Search logs (POST)

Search logs (POST).

Search metrics

Search metric names reported to Datadog in the last 24 hours.

Search monitor groups

Searches triggered Datadog monitor groups using monitor-group query grammar.

Search monitors

Search monitor configurations using Datadog's monitor query grammar.

Search for SLOs

Search for SLOs.

Search Spans Analytics

Search and analyze Datadog trace span data using filters, grouping, and aggregations.

Search test suites

Search test suites.

Search Synthetic tests

Search Synthetic tests.

Search Traces

Search Datadog APM span events across services using a query and time window, for investigating request flows and performance issues.

Send shared dashboard invitation email

Send shared dashboard invitation email.

Save new value for on-demand concurrency cap

Save new value for on-demand concurrency cap.

Set On-Call team routing rules

Replaces (sets) the On-Call routing rules for a Datadog team.

Submit distribution points

Submit distribution points.

Send logs

Send logs.

Submit metrics

Submits custom metrics to Datadog.

Submit metrics

Submit metrics.

Submit a Service Check

Submit one or more service checks using POST /api/v1/check_run.

Trigger tests from CI/CD pipelines

Trigger tests from CI/CD pipelines.

Trigger Synthetic tests

Trigger Synthetic tests.

Unmute Monitor

Unmute a monitor in Datadog.

Edit an API test

Edit an API test.

Edit a browser test

Edit a browser test.

Update Dashboard

Update a dashboard in Datadog.

Update a dashboard list

Update a dashboard list.

Update items of a dashboard list

Replace the dashboards in a manual dashboard list with the supplied list using PUT /api/v2/dashboard/lists/manual/{dashboard_list_id}/dashboards.

Update a derived metric

Update a derived metric.

Update a downtime

Update a downtime.

Update On-Call escalation policy

Updates a Datadog On-Call escalation policy by ID.

Update host tags

Updates tags for a specific host in Datadog.

Edit metric metadata

Edit metric metadata.

Edit a mobile test

Edit a mobile test.

Update monitor

Updates an existing Datadog monitor with new configuration, thresholds, or notification settings.

Edit a monitor configuration policy

Edit a monitor configuration policy.

Update a monitor notification rule

Update a monitor notification rule.

Update a notebook

Update a notebook using PUT /api/v1/notebooks/{notebook_id}, supplying the notebook payload in body.

Update On-Call notification rule

Updates an On-Call notification rule for a user by ID.

Edit a private location

Edit a private location.

Update a shared dashboard

Update a shared dashboard.

Update On-Call schedule

Updates a Datadog On-Call schedule by ID.

Update an SLO

Update an SLO.

Update a Synthetics downtime

Update a Synthetics downtime.

Edit a Network Path test

Edit a Network Path test.

Update a tag configuration

Update a tag configuration.

Pause or start a test

Pause or start a test.

Create or update entities

Create or update entities.

Create or update kinds

Create or update kinds.

Validate API and application keys

Check that the API and application keys are both valid.

Validate monitor

Validate a Datadog monitor definition without creating or updating it.

Validate monitor update

Validate a proposed configuration for an existing monitor without applying it.

FRAMEWORKS

How to build Datadog MCP Agent with another framework

Claude Code logo

Claude Code

Use Datadog MCP with Claude Code

Cursor logo

Cursor

Use Datadog MCP with Cursor

ChatGPT logo

ChatGPT

Use Datadog MCP with ChatGPT

Claude Cowork logo

Claude Cowork

Use Datadog MCP with Claude Cowork

Antigravity logo

Antigravity

Use Datadog MCP with Antigravity

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Datadog MCP with OpenAI Agents SDK

Claude Agent SDK logo

Claude Agent SDK

Use Datadog MCP with Claude Agent SDK

Codex logo

Codex

Use Datadog MCP with Codex

Kimi Code logo

Kimi Code

Use Datadog MCP with Kimi Code

Grok Build logo

Grok Build

Use Datadog MCP with Grok Build

VS Code logo

VS Code

Use Datadog MCP with VS Code

OpenCode logo

OpenCode

Use Datadog MCP with OpenCode

OpenClaw logo

OpenClaw

Use Datadog MCP with OpenClaw

Hermes logo

Hermes

Use Datadog MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Datadog MCP with Atomic Agent

Pi logo

Pi

Use Datadog MCP with Pi

DeepSeek Harness logo

DeepSeek Harness

Use Datadog MCP with DeepSeek Harness

CLI logo

CLI

Use Datadog MCP with CLI

Google ADK logo

Google ADK

Use Datadog MCP with Google ADK

LangChain logo

LangChain

Use Datadog MCP with LangChain

Mastra AI logo

Mastra AI

Use Datadog MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Datadog MCP with LlamaIndex

CrewAI logo

CrewAI

Use Datadog MCP with CrewAI

Pydantic AI logo

Pydantic AI

Use Datadog MCP with Pydantic AI

AutoGen logo

AutoGen

Use Datadog MCP with AutoGen

FAQ

Frequently asked questions

With a standalone Datadog MCP server, the agents and LLMs can only access a fixed set of Datadog tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Datadog and many other apps based on the task at hand, all through a single MCP endpoint.

Yes, you can. Vercel AI SDK v6 fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Datadog tools.

Yes, absolutely. You can configure which Datadog scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Datadog data and credentials are handled as safely as possible.

Start with Datadog.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Datadog tool your agent needs.Free to start.

Start building