SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Datadog MCP with LlamaIndex

Connect LlamaIndex 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 LlamaIndex 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 LlamaIndex 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 ADKLangChainVercel AI SDKMastra AICrewAIPydantic AIAutoGen

TL;DR

Here's what you'll learn:
  • Set your OpenAI and Composio API keys
  • Install LlamaIndex and Composio packages
  • Create a Composio Tool Router session for Datadog
  • Connect LlamaIndex to the Datadog MCP server
  • Build a Datadog-powered agent using LlamaIndex
  • Interact with Datadog through natural language

What is LlamaIndex?

LlamaIndex is a data framework for building LLM applications. It provides tools for connecting LLMs to external data sources and services through agents and tools.

Key features include:

  • ReAct Agent: Reasoning and acting pattern for tool-using agents
  • MCP Tools: Native support for Model Context Protocol
  • Context Management: Maintain conversation context across interactions
  • Async Support: Built for async/await patterns

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 step10 STEPS
1

Prerequisites

Before you begin, make sure you have:
  • Python 3.8/Node 16 or higher installed
  • A Composio account with the API key
  • An OpenAI API key
  • A Datadog account and project
  • Basic familiarity with async Python/Typescript
2

Getting API Keys for OpenAI, Composio, and Datadog

OpenAI API key (OPENAI_API_KEY)
  • Go to the OpenAI dashboard
  • Create an API key if you don't have one
  • Assign it to OPENAI_API_KEY in .env
Composio API key and user ID
  • Log into the Composio dashboard
  • Copy your API key from Settings
    • Use this as COMPOSIO_API_KEY
  • Pick a stable user identifier (email or ID)
    • Use this as COMPOSIO_USER_ID
3

Installing dependencies

npm install @composio/llamaindex @llamaindex/openai @llamaindex/tools @llamaindex/workflow dotenv

Create a new Typescript project and install the necessary dependencies:

  • @composio/llamaindex: Composio's LlamaIndex integration
  • @llamaindex/openai: OpenAI LLM integration
  • @llamaindex/tools: MCP client for LlamaIndex
  • @llamaindex/workflow: Workflow framework for LlamaIndex
  • dotenv: Environment variable management
4

Set environment variables

bash
OPENAI_API_KEY=your-openai-api-key
COMPOSIO_API_KEY=your-composio-api-key
COMPOSIO_USER_ID=your-user-id

Create a .env file in your project root:

These credentials will be used to:

  • Authenticate with OpenAI's GPT-5 model
  • Connect to Composio's Tool Router
  • Identify your Composio user session for Datadog access
5

Import modules

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

Create a new file called datadog_llamaindex_agent.ts and import the required modules:

Key imports:

  • dotenv.config loads .env at runtime
  • readline gives us a simple CLI chat loop
  • Composio is the main Composio SDK client
  • mcp connects to an MCP endpoint
  • createAgent builds a LlamaIndex agent
  • openai configures the LLM backend
6

Load environment variables and initialize Composio

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!COMPOSIO_API_KEY) throw new Error("COMPOSIO_API_KEY is not set");
if (!COMPOSIO_USER_ID) throw new Error("COMPOSIO_USER_ID is not set");

What's happening:

This ensures missing credentials cause early, clear errors before the agent attempts to initialise.

7

Create a Tool Router session and build the agent function

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["datadog"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
        description : "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Datadog actions." ,
    llm,
    tools,
  });

  return agent;
}

What's happening here:

  • We create a Composio client using your API key and configure it with the LlamaIndex provider
  • We then create a tool router MCP session for your user, specifying the toolkits we want to use (in this case, datadog)
  • The session returns an MCP HTTP endpoint URL that acts as a gateway to all your configured tools
  • LlamaIndex will connect to this endpoint to dynamically discover and use the available Datadog tools.
  • The MCP tools are mapped to LlamaIndex-compatible tools and plug them into the Agent.
8

Create an interactive chat loop

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

What's happening:

  • We're creating a direct terminal interface to chat with Datadog
  • The LLM's responses are streamed to the CLI for faster interaction.
  • The agent uses context to maintain conversation history
  • The agent processes the request, selects appropriate Datadog tools, and returns a result
  • We extract the answer from the result data structure and display it to the user
  • You can type 'quit' or 'exit' to stop the chat loop gracefully
  • Agent responses and any errors are streamed in a clear, readable format
9

Define the main entry point

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err) {
    console.error("Failed to start agent:", err);
    process.exit(1);
  }
}

main();

What's happening here:

  • We're orchestrating the entire application flow
  • The agent gets built with proper error handling
  • Then we kick off the interactive chat loop so you can start talking to Datadog
10

Run the agent

npx ts-node llamaindex-agent.ts

When prompted, authenticate and authorise your agent with Datadog, then start asking questions.

Complete Code

Here's the complete code to get you started with Datadog and LlamaIndex:

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";
import { LlamaindexProvider } from "@composio/llamaindex";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) {
    throw new Error("OPENAI_API_KEY is not set in the environment");
  }
if (!COMPOSIO_API_KEY) {
    throw new Error("COMPOSIO_API_KEY is not set in the environment");
  }
if (!COMPOSIO_USER_ID) {
    throw new Error("COMPOSIO_USER_ID is not set in the environment");
  }

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["datadog"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
    description:
      "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Datadog actions." ,
    llm,
    tools,
  });

  return agent;
}

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err: any) {
    console.error("Failed to start agent:", err?.message ?? err);
    process.exit(1);
  }
}

main();

Conclusion

You've successfully connected Datadog to LlamaIndex through Composio's Tool Router MCP layer. Key takeaways:
  • Tool Router dynamically exposes Datadog tools through an MCP endpoint
  • LlamaIndex's ReActAgent handles reasoning and orchestration; Composio handles integrations
  • The agent becomes more capable without increasing prompt size
  • Async Python provides clean, efficient execution of agent workflows
You can easily extend this to other toolkits like Gmail, Notion, Stripe, GitHub, and more by adding them to the toolkits parameter.
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

Vercel AI SDK logo

Vercel AI SDK

Use Datadog MCP with Vercel AI SDK

Mastra AI logo

Mastra AI

Use Datadog MCP with Mastra AI

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. LlamaIndex 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