SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Datadog MCP with Autogen

Connect Autogen 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 AutoGen 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 AutoGen 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 AILlamaIndexCrewAIPydantic AI

TL;DR

Here's what you'll learn:
  • Get and set up your OpenAI and Composio API keys
  • Install the required dependencies for Autogen and Composio
  • Initialize Composio and create a Tool Router session for Datadog
  • Wire that MCP URL into Autogen using McpWorkbench and StreamableHttpServerParams
  • Configure an Autogen AssistantAgent that can call Datadog tools
  • Run a live chat loop where you ask the agent to perform Datadog operations

What is AutoGen?

Autogen is a framework for building multi-agent conversational AI systems from Microsoft. It enables you to create agents that can collaborate, use tools, and maintain complex workflows.

Key features include:

  • Multi-Agent Systems: Build collaborative agent workflows
  • MCP Workbench: Native support for Model Context Protocol tools
  • Streaming HTTP: Connect to external services through streamable HTTP
  • AssistantAgent: Pre-built agent class for tool-using assistants

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

Prerequisites

You will need:

  • A Composio API key
  • An OpenAI API key (used by Autogen's OpenAIChatCompletionClient)
  • A Datadog account you can connect to Composio
  • Some basic familiarity with Autogen and Python async
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 dependencies

bash
pip install composio python-dotenv
pip install autogen-agentchat autogen-ext-openai autogen-ext-tools

Install Composio, Autogen extensions, and dotenv.

What's happening:

  • composio connects your agent to Datadog via MCP
  • autogen-agentchat provides the AssistantAgent class
  • autogen-ext-openai provides the OpenAI model client
  • autogen-ext-tools provides MCP workbench support

4

Set up environment variables

bash
COMPOSIO_API_KEY=your-composio-api-key
OPENAI_API_KEY=your-openai-api-key
USER_ID=your-user-identifier@example.com

Create a .env file in your project folder.

What's happening:

  • COMPOSIO_API_KEY is required to talk to Composio
  • OPENAI_API_KEY is used by Autogen's OpenAI client
  • USER_ID is how Composio identifies which user's Datadog connections to use
5

Import dependencies and create Tool Router session

python
import asyncio
import os
from dotenv import load_dotenv
from composio import Composio

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StreamableHttpServerParams

load_dotenv()

async def main():
    # Initialize Composio and create a Datadog session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["datadog"]
    )
    url = session.mcp.url
What's happening:
  • load_dotenv() reads your .env file
  • Composio(api_key=...) initializes the SDK
  • create(...) creates a Tool Router session that exposes Datadog tools
  • session.mcp.url is the MCP endpoint that Autogen will connect to
6

Configure MCP parameters for Autogen

python
# Configure MCP server parameters for Streamable HTTP
server_params = StreamableHttpServerParams(
    url=url,
    timeout=30.0,
    sse_read_timeout=300.0,
    terminate_on_close=True,
    headers={"x-api-key": os.getenv("COMPOSIO_API_KEY")}
)

Autogen expects parameters describing how to talk to the MCP server. That is what StreamableHttpServerParams is for.

What's happening:

  • url points to the Tool Router MCP endpoint from Composio
  • timeout is the HTTP timeout for requests
  • sse_read_timeout controls how long to wait when streaming responses
  • terminate_on_close=True cleans up the MCP server process when the workbench is closed
7

Create the model client and agent

python
# Create model client
model_client = OpenAIChatCompletionClient(
    model="gpt-5",
    api_key=os.getenv("OPENAI_API_KEY")
)

# Use McpWorkbench as context manager
async with McpWorkbench(server_params) as workbench:
    # Create Datadog assistant agent with MCP tools
    agent = AssistantAgent(
        name="datadog_assistant",
        description="An AI assistant that helps with Datadog operations.",
        model_client=model_client,
        workbench=workbench,
        model_client_stream=True,
        max_tool_iterations=10
    )

What's happening:

  • OpenAIChatCompletionClient wraps the OpenAI model for Autogen
  • McpWorkbench connects the agent to the MCP tools
  • AssistantAgent is configured with the Datadog tools from the workbench
8

Run the interactive chat loop

python
print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
print("Ask any Datadog related question or task to the agent.\n")

# Conversation loop
while True:
    user_input = input("You: ").strip()

    if user_input.lower() in ["exit", "quit", "bye"]:
        print("\nGoodbye!")
        break

    if not user_input:
        continue

    print("\nAgent is thinking...\n")

    # Run the agent with streaming
    try:
        response_text = ""
        async for message in agent.run_stream(task=user_input):
            if hasattr(message, "content") and message.content:
                response_text = message.content

        # Print the final response
        if response_text:
            print(f"Agent: {response_text}\n")
        else:
            print("Agent: I encountered an issue processing your request.\n")

    except Exception as e:
        print(f"Agent: Sorry, I encountered an error: {str(e)}\n")
What's happening:
  • The script prompts you in a loop with You:
  • Autogen passes your input to the model, which decides which Datadog tools to call via MCP
  • agent.run_stream(...) yields streaming messages as the agent thinks and calls tools
  • Typing exit, quit, or bye ends the loop

Complete Code

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

python
import asyncio
import os
from dotenv import load_dotenv
from composio import Composio

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StreamableHttpServerParams

load_dotenv()

async def main():
    # Initialize Composio and create a Datadog session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["datadog"]
    )
    url = session.mcp.url

    # Configure MCP server parameters for Streamable HTTP
    server_params = StreamableHttpServerParams(
        url=url,
        timeout=30.0,
        sse_read_timeout=300.0,
        terminate_on_close=True,
        headers={"x-api-key": os.getenv("COMPOSIO_API_KEY")}
    )

    # Create model client
    model_client = OpenAIChatCompletionClient(
        model="gpt-5",
        api_key=os.getenv("OPENAI_API_KEY")
    )

    # Use McpWorkbench as context manager
    async with McpWorkbench(server_params) as workbench:
        # Create Datadog assistant agent with MCP tools
        agent = AssistantAgent(
            name="datadog_assistant",
            description="An AI assistant that helps with Datadog operations.",
            model_client=model_client,
            workbench=workbench,
            model_client_stream=True,
            max_tool_iterations=10
        )

        print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
        print("Ask any Datadog related question or task to the agent.\n")

        # Conversation loop
        while True:
            user_input = input("You: ").strip()

            if user_input.lower() in ['exit', 'quit', 'bye']:
                print("\nGoodbye!")
                break

            if not user_input:
                continue

            print("\nAgent is thinking...\n")

            # Run the agent with streaming
            try:
                response_text = ""
                async for message in agent.run_stream(task=user_input):
                    if hasattr(message, 'content') and message.content:
                        response_text = message.content

                # Print the final response
                if response_text:
                    print(f"Agent: {response_text}\n")
                else:
                    print("Agent: I encountered an issue processing your request.\n")

            except Exception as e:
                print(f"Agent: Sorry, I encountered an error: {str(e)}\n")

if __name__ == "__main__":
    asyncio.run(main())

Conclusion

You now have an Autogen assistant wired into Datadog through Composio's Tool Router and MCP. From here you can:
  • Add more toolkits to the toolkits list, for example notion or hubspot
  • Refine the agent description to point it at specific workflows
  • Wrap this script behind a UI, Slack bot, or internal tool
Once the pattern is clear for Datadog, you can reuse the same structure for other MCP-enabled apps with minimal code changes.
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

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

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