- Category: server monitoring
- Auth: DCR_OAUTH
- Composio-managed OAuth available? No
- Tools: 370
- Triggers: 0
- Slug:
DATADOG_MCP - Version: 20261018_00
Tools
Aap get activation options
Aap get activation options
DATADOG_MCP_AAP_GET_ACTIVATION_OPTIONSCheck whether Datadog App and API Protection (AAP) can be enabled for a service via Remote Configuration (RC), with no code changes. Use when the user asks to install, set up, enable, or onboard AAP for a service and environment. Returns a verdict with a recommended navigation action: the Service Inventory side-panel when RC is available, or the AAP setup page otherwise.Input Parameters
Aap onboarding
Aap onboarding
DATADOG_MCP_AAP_ONBOARDINGStep-by-step instructions for enabling Datadog App and API Protection (AAP) to monitor and secure your application. AAP detects security threats, vulnerabilities, and attacks in real time by using Datadog tracing libraries for application deployments, the Datadog security processor for Envoy deployments, the Datadog SPOA for HAProxy deployments, or the Datadog nginx module for nginx deployments. You MUST first review the user’s project and fill out as many arguments as possible before calling this tool. You MUST NOT call this tool without first examining the project’s codebase to determine the correct argument values.Input Parameters
Add llmobs annotation queue interactions
Add llmobs annotation queue interactions
DATADOG_MCP_ADD_LLMOBS_ANNOTATION_QUEUE_INTERACTIONSQueue traces, sessions, or spans for human review in an annotation queue.This is how findings become review work: use search_llmobs_spans or find_llmobs_error_spans to identify the traces worth grading, then queue them here.Returns interactions — each with the id that upsert_llmobs_annotations writes labels against — and an errors array for the items that did not land. Re-adding content the queue already holds is not an error: the existing interaction comes back with already_existed: true.Queueing content does not annotate it. Grade it with upsert_llmobs_annotations.Input Parameters
Add llmobs dataset records
Add llmobs dataset records
DATADOG_MCP_ADD_LLMOBS_DATASET_RECORDSCreate records in a dataset. Two-step: PREVIEW (confirmed=false) → INSERT (confirmed=true).confirmed=false: does NOT insert. Validates that the (project_id, dataset_id) pair exists, then returnsAddDatasetRecordsPreviewwith the resolved IDs, planned record count, tag union, first-record content, and aconfirmation_promptstring. If the dataset does not exist, returnsDatasetRecordToolError(reason="unknown_dataset")— re-resolve by NAME via get_llmobs_project + list_llmobs_datasets and retry rather than telling the user the dataset was deleted. Show the preview to the user, ask for explicit approval, then re-call withconfirmed=true.confirmed=true: validates UUIDs, issues the API call. Author is recorded automatically as the human user from the forwarded JWT — do not pass an author ID.
create_new_version=true (default) bumps the dataset version on insert (the typical “save as a new versioned snapshot” — what experimentation needs). Set false only for in-place batched edits where the user explicitly asked to keep the current version.On failure returns DatasetRecordToolError with reason, recovery_hint, and the offending value. Reasons: invalid_project_id, invalid_dataset_id, unknown_dataset, forbidden_action_dataset, record_size_exceeded, invalid_request, transport_error.Once confirmed=true succeeds, do NOT retry the call (the work is committed). If a network error makes the result ambiguous, call get_llmobs_dataset_records to verify before retrying.When the user wants to append records, sample existing records via get_llmobs_dataset_records first, read the schema_summary, and construct matching new records before this tool. Always preview (confirmed=false) and confirm with the user before writing.Input Parameters
Aggregate datadog ci pipeline events
Aggregate datadog ci pipeline events
DATADOG_MCP_AGGREGATE_DATADOG_CI_PIPELINE_EVENTSAggregate and analyze CI pipeline events to produce statistics, metrics, and grouped analytics. Use it for questions such as average pipeline duration or failed builds per pipeline. For individual event details or error messages, use search_datadog_ci_pipeline_events instead.aggregation is required and must be one of count, cardinality, avg, sum, min, max, pc50, pc75, pc90, pc95, or pc99. Use cardinality with metric set to a facet (such as @ci.pipeline.id) to count distinct values. If no data is available, try a wider time range. Results are ordered by aggregation value descending; use search_datadog_ci_pipeline_events for sorted individual event listings.If unsure whether a facet exists or needs an @ prefix, read the datadog://mcp/ci-pipeline-facets resource.Input Parameters
Aggregate datadog test events
Aggregate datadog test events
DATADOG_MCP_AGGREGATE_DATADOG_TEST_EVENTSAggregate Datadog test events for reliability, performance, and execution trends. Use search_datadog_test_events for individual event details. aggregation is required and must be one of count, cardinality, avg, sum, min, max, pc50, pc75, pc90, pc95, or pc99. Use cardinality with metric set to a facet (such as @test.name) to count distinct values. Use at most two or three group_by facets and add filters to stay within the 10,000-group limit. If unsure whether a facet exists or needs an @ prefix, read the datadog://mcp/ci-test-facets resource.Input Parameters
Aggregate dora events
Aggregate dora events
DATADOG_MCP_AGGREGATE_DORA_EVENTSAggregate DORA events into scalar values or timeseries using composable queries and formulas. Each query selects a DORA index, optional metric, aggregation, filter, and group_by facets. Use get_dora_fields to discover valid indexes, measures, facets, cardinality fields, and aggregations.Input Parameters
Aggregate events
Aggregate events
DATADOG_MCP_AGGREGATE_EVENTSAggregate Datadog events to compute counts, sums, averages, min, max, cardinality, and percentiles (P50, P75, P90, P95, P98, P99), with optional grouping by fields or time intervals. Use this for aggregated analysis such as event counts by source, event frequency over time, or grouped summaries across tags. For raw event inspection, titles/messages, or tag exploration, use search_datadog_events.Input Parameters
Aggregate rum events
Aggregate rum events
DATADOG_MCP_AGGREGATE_RUM_EVENTSAggregate Datadog RUM events to compute counts, sums, averages, min, max, cardinality, and percentiles (P50, P75, P90, P95, P98, P99), with optional grouping by fields or time intervals. Use this for aggregated analysis of RUM data such as session counts over time, error counts by page, or p95 loading times by browser or URL path. For raw event inspection or attribute discovery, use search_datadog_rum_events.Input Parameters
@view.loading_time, @action.loading_time, @resource.duration) are in nanoseconds (1s = 1e9). Examples: ‘@type:error’, ‘@type:view @view.loading_time:>5000000000’ (>5s), ’*’ for all events. IMPORTANT: free-text search uses full-word matching — dots (.) are NOT word separators (foo.bar is one token, bar alone matches nothing). Wrap partial terms in wildcards or target the attribute: @error.message:*bar*.Aggregate spans
Aggregate spans
DATADOG_MCP_AGGREGATE_SPANSAggregate Datadog APM spans to compute counts, sums, averages, min, max, cardinality, and percentiles (P50, P75, P90, P95, P98, P99), with optional grouping by fields or time intervals. Use this for aggregated analysis such as request counts over time, p95 duration by service or resource, or error counts grouped by endpoint or status code. For raw span inspection or to discover fields to group by or aggregate on, first use search_datadog_spans and optionally request custom_attributes.Input Parameters
Analyse datadog k8s rollout
Analyse datadog k8s rollout
DATADOG_MCP_ANALYSE_DATADOG_K8S_ROLLOUTAssemble a Kubernetes Deployment rollout in one call: status, progress, timing (ETA while in progress, duration once finished), the new/previous/old ReplicaSet split by revision, and before/after impact series (RED, resource utilization, log counts).Prefer this over stitching together search_datadog_k8s_resources and describe_datadog_k8s_resource for rollout questions. Values are already computed; do not re-derive them.Only reports on Deployments whose kube_rollout_status is inprogress, recentlycompleted or recentlyfailed. Any other Deployment returns its own fields plus a warning, because a rollout that finished long ago has nothing to analyse.Load the datadog/analyze-kubernetes-rollout skill to turn this output into an answer. It carries the summary format to present, how to read the impact series, pacing and maxSurge/maxUnavailable advice, and how to name the blocker when a rollout is stuck — none of which is derivable from this payload. Do not hand back the raw JSON.IMPORTANT: Either uid OR resource_identifiers MUST be provided. If both are provided, uid takes precedence and resource_identifiers is ignored.- Use resource_identifiers when you know the Deployment details (cluster, namespace, name) - DO NOT search first
- Use uid ONLY if you obtained it from a previous search
Input Parameters
Analyze cloud network monitoring
Analyze cloud network monitoring
DATADOG_MCP_ANALYZE_CLOUD_NETWORK_MONITORINGQueries Cloud Network Monitoring (CNM) data to view network/transport level information. Use to investigate netork latency, packet loss, TCP failed connections, dial timeouts, or spikes in TCP throughput.Each query accepts a ‘scope’ field to select which slice of CNM data to query:- ‘tcp’ (default): service-to-service L4/TCP flows. Use for investigating connection errors between workloads.
- ‘tcp-eudm’: endpoint/device-centric L4 flows. Use for investigating networking issues originating from end-user devices rather than between services.
Input Parameters
Analyze datadog error tracking errors
Analyze datadog error tracking errors
DATADOG_MCP_ANALYZE_DATADOG_ERROR_TRACKING_ERRORSAnalyze Datadog Error Tracking error samples with SQL — aggregations, breakdowns by tag/service/version, or raw sample inspection. Runs against a virtual ‘errors’ table of individual error events (not Issues, which are groups of errors). Column names: no @ = root/tag attribute (e.g. usr.id, service), @ = custom attribute (e.g. @my.field). For ranked Issues by priority/volume use search_datadog_error_tracking_issues — do not GROUP BY issue.id as a substitute. Over wide time ranges, add LIMIT or a narrow GROUP BY; shorten the range if it times out.Input Parameters
Analyze datadog logs
Analyze datadog logs
DATADOG_MCP_ANALYZE_DATADOG_LOGSAnalyze Datadog logs using SQL. Runs against a virtual ‘logs’ table filtered by your search query. Good for aggregations, counts, group-bys, or peeking at recent logs with LIMIT. To discover custom attributes for extra_columns, first call search_datadog_logs with extra_fields. If a query times out, try a shorter time range. MUST load the datadog/ddsql skill before calling this tool.Input Parameters
custom.X → {name: "@X"}, attributes.X → {name: "@X"}, error.X → {name: "@error.X"}; tags from the tags: list use bare names without ’@’ — e.g. tag team:foo → {name: "team"}. Never pass the raw response-prefixed form (e.g. never custom.X or attributes.X). Supported types: varchar, bigint, decimal, boolean, timestamp, array<varchar>, array<bigint>, array<decimal>, array<boolean>, array<timestamp>.Analyze datadog security findings
Analyze datadog security findings
DATADOG_MCP_ANALYZE_DATADOG_SECURITY_FINDINGSPrimary tool for analyzing security findings. Use this for all security findings analysis tasks. REQUIRED: Call get_datadog_security_findings_schema FIRST to get available fields and their types before writing SQL. Queries live data from the last 24 hours using flexible SQL aggregations, filtering, and grouping. IMPORTANT: When users ask ‘what should I fix?’ or ‘what are my top vulnerabilities?’, prioritize by RISK ATTRIBUTES (@risk.*) not just severity. DEEP LINKS: Always link to findings when you have the id — format: <deep_link_base_url>/security/finding/<finding_id>. The correct base URL is in every response as ‘deep_link_base_url’. Read the sql_query parameter description carefully — it explains risk-based prioritization, deep link generation, function syntax, common pitfalls, and includes examples. Only fall back to search_datadog_security_findings if you need full finding details or this tool fails. To create a case, Jira issue, or ServiceNow ticket for findings, use create_datadog_security_findings_ticket.Input Parameters
Analyze datadog security signals
Analyze datadog security signals
DATADOG_MCP_ANALYZE_DATADOG_SECURITY_SIGNALSCount, group, or trend security signals using DDSQL — for any aggregate question: ‘how many’, ‘top N’, ‘by severity’, ‘over time’, or breakdown. Do NOT use for listing, retrieving, or checking existence of specific signals — use search_datadog_security_signals instead. IMPORTANT: When constructing the SQL query, ALWAYS use the table-valued function syntax — FROM dd.security_signals(columns => ARRAY[…], filter => ’…’). IMPORTANT: If the user has NOT specified a signal product (Cloud SIEM / Log Detection, App & API Protection / Application Security, or Workload Protection / Workload Security), ASK them if they want to specify the product or rule type before calling this tool. Workflow: ALWAYS call get_datadog_security_signals_schema first to discover available fields, then use this tool with SQL.Input Parameters
Analyze security findings
Analyze security findings
DATADOG_MCP_ANALYZE_SECURITY_FINDINGSPrimary tool for analyzing security findings. (Also available as analyze_datadog_security_findings.) Use this for all security findings analysis tasks. REQUIRED: Call security_findings_schema FIRST to get available fields and their types before writing SQL.Input Parameters
Append new rum retention filter
Append new rum retention filter
DATADOG_MCP_APPEND_NEW_RUM_RETENTION_FILTERCreate a new RUM retention filter, appended at the end of the evaluation order. Retention filters control which RUM events are indexed and retained.This changes data-retention configuration and directly affects billing. Adding a filter or enabling cross-product sampling increases indexed volume and cost. Always confirm the exact change with the user before calling. Never create a filter speculatively.name, event_type, and sample_rate are required. event_type: one of session, view, action, error, resource, long_task, vital, operation. sample_rate: 0.1 to 100 (percent of matching events retained). cross_product_sampling: optional extra retention for session replays and APM traces of matching sessions; session_replay_sample_rate and trace_sample_rate are both required within it.The new filter is appended at the end of the evaluation order. Filters are evaluated top-down, so a broad catch-all already at the end may capture matching events before this filter applies; reorder afterwards with reorder_rum_retention_filters to place specific filters above broad ones. Creates are idempotent: a retried create that matches an existing filter exactly is not duplicated.To change an existing filter use update_rum_retention_filter; to remove one use delete_rum_retention_filter. Find existing filters with search_rum_retention_filters.Input Parameters
Append reference table rows
Append reference table rows
DATADOG_MCP_APPEND_REFERENCE_TABLE_ROWSAppend (add) new rows to an existing reference table. Prefer upsert_reference_table_rows when you may need to update existing rows — it handles both inserts and updates. Use this tool only when you are certain all rows are new. Each row must include all required fields from the table’s schema, including the primary key field. Use list_reference_tables to discover table IDs and schemas first. Example: rows: [{“user_id”: “user001”, “name”: “Alice”, “age”: 25}, {“user_id”: “user002”, “name”: “Bob”, “age”: 30}]Input Parameters
Archive-feature-flag
Archive-feature-flag
Archive-saved-filter
Archive-saved-filter
Ask widget expert
Ask widget expert
DATADOG_MCP_ASK_WIDGET_EXPERTGet targeted instructions for building a Datadog widget. Returns a concise how-to guide — widget type recommendations, required fields, schema patterns, and an annotated example — that you use to build the widget definition yourself. The expert has deep knowledge of all widget types and schemas but does NOT have access to real telemetry, live data, or the user’s environment.Any examples in the response use PLACEHOLDER values for queries. You are responsible for discovering real metric names, log queries, or APM resource names through data exploration tools and substituting them — do not copy example queries directly into a widget without first validating them against real data.Returns focused instructions rather than a full schema dump, so it’s cheaper than get_widget_reference. Useful at any stage: choosing a widget type, understanding schema requirements, or debugging an invalid widget.Input Parameters
Assign datadog security findings
Assign datadog security findings
DATADOG_MCP_ASSIGN_DATADOG_SECURITY_FINDINGSAssign or unassign security findings to a user. Assignment cascades to linked cases — assigning a finding auto-assigns its linked case. Use analyze_datadog_security_findings or search_datadog_security_findings to find specific finding IDs first. To unassign, omit assignee. IMPORTANT: Always confirm with the user before calling this tool — it changes finding state.Input Parameters
Batch update llmobs dataset records
Batch update llmobs dataset records
DATADOG_MCP_BATCH_UPDATE_LLMOBS_DATASET_RECORDSInsert, update, and delete dataset records in one versioned operation. Use this to edit or remove existing records; add_llmobs_dataset_records is the append-only path and is preferable when you are only adding.Two-step: PREVIEW (confirmed=false) → APPLY (confirmed=true).confirmed=false: writes nothing. Verifies the dataset exists and returns the per-operation counts plus aconfirmation_prompt. Show it to the user and get explicit approval.confirmed=true: applies the whole batch atomically. Do not retry a successful call; verify with get_llmobs_dataset_records if a network error left the outcome ambiguous.
update_records / delete_record_ids with get_llmobs_dataset_records first, and read its schema_summary so inserted records match the existing shape. At most 500 mutations per call.On invalid input or API failure returns a DatasetRecordToolError with reason + recovery_hint.Input Parameters
Browser onboarding
Browser onboarding
DATADOG_MCP_BROWSER_ONBOARDINGStep-by-step instructions for adding initial Datadog setup to a frontend browser-based project environment. You must first review the user’s project and this tool’s arguments (including nested arguments) and fill out as many of them as possible before calling this tool. Check project files and dependencies to determine the argument values, focusing on dependency files and imports. Only provide values you can substantiate from the user’s files. If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer. Before calling this tool, you must first check if the user’s project has already been configured for Datadog on the frontend. If it has, you should not call this tool. Use CLI utilities, such as ls and cat when checking if the project contains existing env files and viewing their contents, respectively. For projects with client- and server-side logic, you must check if the client side has already been configured for Datatdog, and if not, you must call this tool to configure the client side.Input Parameters
Build audit trail query
Build audit trail query
DATADOG_MCP_BUILD_AUDIT_TRAIL_QUERYTranslates a natural-language description into a correct Audit Trail query string. Returns query/from/to fields (plus optional visualization hints) that can be used wherever an Audit Trail query is needed — e.g. feed them to search_audit_events, link the user to the Audit Trail Explorer, or use them in any other Audit Trail query consumer. Call this tool only when unsure of Audit Trail query syntax; if you already know the correct syntax, query directly via search_audit_events or list_audit_events (this tool runs an LLM and adds latency).Input Parameters
Cancel datadog workflow instance
Cancel datadog workflow instance
DATADOG_MCP_CANCEL_DATADOG_WORKFLOW_INSTANCECancel a running Datadog Workflow Automation execution instance. Invoke only when the user intends to stop the run. The instanceId can come from execute_datadog_workflow or list_datadog_workflow_instances. Cancellation cannot be resumed. On success, the result contains cancelled: true, workflowId, and instanceId.Input Parameters
Check-flag-implementation
Check-flag-implementation
DATADOG_MCP_CHECK_FLAG_IMPLEMENTATIONPRIMARY TOOL FOR EXISTING FLAGS! This tool should be used to check how a feature flag should be implemented in codebase. Use this when asked:- Check my flags are used properly?
- Use an existing flag to control some functionality in my code?
- Use the flag ‘some-flag’ to control something in my code? (This implies there is an existing feature flag with key ‘some-flag’)
- Debug why this flag is not serving the variant I think it should.
- being used as the correct type
- being passed all the context attributes it needs to evaluate
- providing an appropriate default value This is helpful because these things can’t be verified by normal static analysis, so this tool is needed. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools.
Input Parameters
Clean-up-flag
Clean-up-flag
DATADOG_MCP_CLEAN_UP_FLAGClean up a stale feature flag by key — auto-archives if no code references are known, otherwise returns the repos and files where the flag is still referenced plus a Datadog UI link and instructs the user to use Bits dev in the UI to remove those references (archiving stays blocked until they are gone).Input Parameters
Clone datadog form
Clone datadog form
Clone llmobs dataset
Clone llmobs dataset
DATADOG_MCP_CLONE_LLMOBS_DATASETCopy a dataset’s current records into a new dataset in the same project. The source dataset is left untouched.This is the safe way to try edits against a real dataset: clone it, mutate the clone with batch_update_llmobs_dataset_records, and run experiments against the clone.Returns the new dataset and source_dataset_id. On invalid input or API failure returns a DatasetRecordToolError.Only the source’s current version is copied; the clone starts its own version history.Input Parameters
Code coverage onboarding
Code coverage onboarding
DATADOG_MCP_CODE_COVERAGE_ONBOARDINGConfigure Datadog Code Coverage for a project by adding coverage report uploads to the CI pipeline. Call this tool to set up code coverage, add code coverage, enable code coverage uploads, or integrate Datadog Code Coverage into a repository. This tool returns all the instructions needed — do NOT search the web, fetch documentation, or read external resources. Only inspect local project files to determine this tool’s argument values, then call this tool immediately. Check CI config files (e.g. .github/workflows/), dependency files, and coverage tool configs to fill in the arguments. Only provide values you can substantiate from the user’s files. Use CLI utilities such as ls and cat to inspect project files. Do not guess or make up values.Input Parameters
Cost recommendations
Cost recommendations
DATADOG_MCP_COST_RECOMMENDATIONSLists an organization’s Cloud Cost Management (CCM) cost-saving recommendations. By default, recommendations are ranked by estimated potential savings (highest first); CCM analyzes cloud and SaaS resource usage and surfaces opportunities to cut spend. Use it to answer questions like ‘what are my top cost-saving opportunities?’, ‘how much could I save per month?’, ‘how much could I save this year?’, ‘how many recommendations do I have?’, or ‘show me aws recommendations for my Kubernetes clusters’. Recommendations carry a status (Open, In Progress, Completed, Dismissed); scope to the right one(s) through the query — see the status guidance on the query argument. For a neutral request, filter to @status:Open (the recs still worth acting on). Output is JSON with three blocks. (1) recommendations: this page’s array; each item has cloud_provider, potential_monthly_savings and potential_yearly_savings (estimated dollars saved per month and per year if the recommended action is taken), recommendation_type, resource_type, resource_id, risk, and effort, when classified. The resource_id field is the recommendation’s stable handle (e.g. ‘k8s_cluster|spheal-b’) that you can pass back as an @id: filter to re-fetch that exact recommendation. When a resource has several recommended actions, only the best one is promoted to these fields; set full_output=true to also get full_event, the recommendation’s complete payload (all actions, status, resource metadata, and every field usable for @-filtering). (2) summary: total_items plus potential_monthly_savings and potential_yearly_savings, as described above; plus complete, which is false when the matching set was too large to fully scan (making those totals lower bounds you should report as ‘at least’). (3) pagination: displayed_items (the count in this page) and next_cursor (pass it back as cursor to fetch the next page; absent on the last page). This tool is visible to every user, but only Cloud Cost Management (CCM) customers have recommendation data. When Event Query reports that the organization has no valid recommendation index (normally because it is not a CCM customer), the tool returns a short plain-text message as a normal non-error result; relay that message as-is and do not retry. A valid index with no recommendations, or a filter with no matches, returns the normal JSON blocks with an empty recommendations array and zero-valued summary.Input Parameters
Create datadog form
Create datadog form
DATADOG_MCP_CREATE_DATADOG_FORMCreate a new Datadog form with a name. The form is created in draft state with a linked datastore auto-provisioned. The schema is unique, you must retrieve it using the get_form_definition_schema tool before attempting to create a form. Returns the new form’s metadata including its ID and datastore_id.Input Parameters
Create datadog monitor
Create datadog monitor
Create datadog notebook
Create datadog notebook
DATADOG_MCP_CREATE_DATADOG_NOTEBOOKCreates a new Datadog notebook. Include key findings, evidence, supporting data, and complete query documentation unless told otherwise. Do not start the first markdown cell with a heading that repeats the notebook name — it is already displayed as the title. Look up widget reference schemas before constructing graph cells.Input Parameters
Create datadog published analysis
Create datadog published analysis
DATADOG_MCP_CREATE_DATADOG_PUBLISHED_ANALYSISCreates a published analysis (also called a published dataset) from a notebook cell. A published analysis is a snapshot of a computational notebook’s cells, exposed as a queryable dataset. Use this to publish a notebook cell as a dataset for the first time.Input Parameters
Create datadog security detection rule
Create datadog security detection rule
DATADOG_MCP_CREATE_DATADOG_SECURITY_DETECTION_RULECreate a new Cloud SIEM detection rule by POSTing the supplied payload to POST /api/v2/security_monitoring/rules. The payload must follow the schema returned by get_datadog_security_detection_rules_schema — call that tool first to fetch the grammar, then construct a payload that matches the detection method you need. The tool automatically appends the datadog_mcp:created tag to the rule payload. For now, payload.type must be log_detection; other rule types are not supported yet. On success, returns the full created rule (including the server-assigned id).Input Parameters
name, type (for now, must be log_detection), message, isEnabled, options (including detectionMethod), queries, and cases (or thirdPartyCases when detectionMethod is third_party). See get_datadog_security_detection_rules_schema for the complete grammar and canonical example payloads.Create datadog security findings automation rule
Create datadog security findings automation rule
DATADOG_MCP_CREATE_DATADOG_SECURITY_FINDINGS_AUTOMATION_RULECreate a security findings automation rule. Specify rule_type to choose the type of rule: mute (suppress findings), due_date (set remediation deadlines), severity_modifier (adjust finding severity), or ticket_creation (auto-create Jira/Case Management tickets). Each rule_type requires different parameters — see parameter descriptions for which apply.Input Parameters
Create datadog security findings ticket
Create datadog security findings ticket
DATADOG_MCP_CREATE_DATADOG_SECURITY_FINDINGS_TICKETCreate a case, Jira issue, ServiceNow ticket, or Linear issue for security findings. Jira/ServiceNow/Linear targets automatically create and link a Case Management case. Title, description, and priority are auto-generated by the backend if omitted — only provide them if the user specifies custom values. project_id is required for jira/servicenow/linear targets — call get_datadog_security_findings_ticket_suggestions first if you don’t know which project to use. If the create request fails, the error response includes ranked project suggestions to help the user pick the right one. IMPORTANT: Always confirm with the user before calling this tool — it creates external tickets.Input Parameters
Create datadog security suppression
Create datadog security suppression
DATADOG_MCP_CREATE_DATADOG_SECURITY_SUPPRESSIONCreate a new security monitoring suppression rule in Datadog. Suppressions prevent detection rules from generating signals for specific conditions. This operation is destructive: once active, future matching signals will be silenced. Call get_datadog_security_detection_rules first to inspect the target rule(s) and build an accurate rule_query. At least one of suppression_query or data_exclusion_query must be provided.Input Parameters
Create datadog skill
Create datadog skill
DATADOG_MCP_CREATE_DATADOG_SKILLCreate a new library skill in your organization’s Skills Library — a separate, user-authored set of task guides, distinct from any built-in “Skills” your own agent tooling may already have. This library skill is always created as private and owned by you, and does not modify or interact with Datadog’s own first-party skills, which are a separate, built-in set you cannot edit through this tool. It is always created private and visible only to its owner: this tool cannot make a library skill Shared with the organization — to share it, the user must open the skill in the Datadog UI and mark it as Shared. Tell the user this after creating a skill they intend to share. Provide a short, unique slug (the identifier), a human-readable name, a one-line description, and the library skill body as content.Input Parameters
Create datadog workflow
Create datadog workflow
DATADOG_MCP_CREATE_DATADOG_WORKFLOWCreate an unpublished Datadog Workflow Automation workflow from a complete spec. Each step must use a catalog actionId and follow its action contract, and the spec must satisfy trigger and graph invariants. Use publish_datadog_workflow when it is ready to run automatically. The result contains the generated workflowId and URL. A successful response confirms that the workflow was saved; it does not establish successful runtime behavior.Omit every step’s display to request automatic layout; if preserving a manual layout, provide display data consistently for all steps.Input Parameters
Create-environment
Create-environment
DATADOG_MCP_CREATE_ENVIRONMENTCreate a new Feature Management environment. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools.Use when reconciliation against list-environments shows a detected DD_ENV value has no covering environment (“will create” outcome), or when a user explicitly wants a new environment.WRITE OPERATION. Before calling, show the user the exact plan (name, queries, is_production, require_feature_flag_approval) and get explicit approval. Production environments have serious operational impact — confirm intent for is_production=true.queries are the DD_ENV values this environment covers (e.g. [“dev”], [“staging”,“stg”]). Wildcards are rejected by the service; DD_ENV values already used in another environment also cause a 409 Conflict.Input Parameters
Create-experiment-feature-flag
Create-experiment-feature-flag
DATADOG_MCP_CREATE_EXPERIMENT_FEATURE_FLAGCreate a new feature flag with a FEATURE_GATE allocation linked to a standard experiment. Use this tool instead of create-feature-flag when an allocation has experiment_id. The allocation schema and environment requirements are otherwise identical to create-feature-flag.MANDATORY: If the user did not specify an environment, ask the user to specify one before creating allocations.This allocation’s exposure_schedule.rollout_options.scheduled_start cannot be a future value (‘relative:<duration>’ or a future ‘absolute:<RFC3339>’) because a standard experiment allocation cannot be auto-started — use ‘none’ and start the experiment through its lifecycle instead. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach.Input Parameters
Create-feature-flag
Create-feature-flag
DATADOG_MCP_CREATE_FEATURE_FLAGPRIMARY TOOL FOR NEW FLAGS in a project that already has Datadog feature flags wired up! *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. Use create-feature-flag when users need to create a new flag that doesn’t exist yet. This tool creates a new feature flag with variants and optional FEATURE_GATE or CANARY allocations. For a FEATURE_GATE allocation linked to a standard experiment with experiment_id, use create-experiment-feature-flag.IMPORTANT: If the project has NO existing feature flags yet (check with list-feature-flags) or the user is asking to set up/add/onboard feature flags for the first time (e.g. “set up feature flags”, “add feature flags to my app”, “onboard this app onto feature flags”, “get started with feature flags”, “start using Datadog feature flags”, “install Datadog feature flags”), use the onboarding flow instead — start with get-onboarding-step rather than this tool. That flow enforces non-production safety gates and real end-to-end CDN verification via verify-onboarding-flag that this tool does not provide.MANDATORY: To correctly implement this flag in your codebase, you MUST use the code demonstrated in the datadog://feature-flags/sdk/react resource. Do not GUESS about how to correctly implement the flag. Do NOT create mock implementations. The user has added this MCP server because they want feature flags server from Datadog. Failure to implement flags as described in datadog://feature-flags/sdk/react will cause frustration.MANDATORY: If the user did not specify an environment, and an allocation is needed or a status is specified, ask the user to specify an environment.When the allocation is already known, prefer creating it atomically with the flag. Later allocation changes use sync-allocations-for-feature-flag-environment, including in production.Each allocation’s exposure_schedule.rollout_options controls when its rollout starts (applies to both CANARY and FEATURE_GATE allocations): use scheduled_start (‘none’, ‘now’, ‘relative:<duration>’, or ‘absolute:<RFC3339>’) rather than the deprecated autostart. A future value (‘relative:<duration>’ or a future ‘absolute:<RFC3339>’) schedules the rollout to start at that time. Exception: a FEATURE_GATE allocation with experiment_id set (a standard experiment allocation) cannot be auto-started, so a future scheduled_start is rejected for it — use ‘none’ and start the experiment through its lifecycle instead. For an APM Canary, set exposure_schedule.apm_retention to {“mode”:“TEMPORARY”,“rate”:1} for a bounded synthetic test. This exercises the deployed retention lifecycle; do not create or override retention filters directly. To enable the new flag before starting its Canary, create with scheduled_start=‘none’, call update-feature-flag-environment with status ENABLED, then call start-canary with the exposure-schedule ID returned by list-allocations-for-feature-flag.Input Parameters
Create global variables
Create global variables
DATADOG_MCP_CREATE_GLOBAL_VARIABLESCreate a Synthetics global variable. name and value are required; value.secure marks the value as hidden after creation, and a secure variable’s value is never returned. tags and description are optional. parse_test_options and parse_test_public_id are not supported by this tool.Input Parameters
Create llmobs annotation queue
Create llmobs annotation queue
DATADOG_MCP_CREATE_LLMOBS_ANNOTATION_QUEUECreate an Agent Observability annotation queue and, optionally, its label schema in the same call.Returns queue with the queue_id every other annotation tool needs, plus the schema with server-assigned label ids.Not name-idempotent — calling twice makes two queues. Check list_llmobs_annotation_queues first if a queue for this purpose may already exist.Defining label_schemas here saves a follow-up update_llmobs_annotation_label_schema call. Next: add_llmobs_annotation_queue_interactions to fill the queue.Input Parameters
score labels take min/max, categorical labels take values. Omit to create an empty queue and define labels later.Create llmobs dataset
Create llmobs dataset
DATADOG_MCP_CREATE_LLMOBS_DATASETCreate an empty dataset inside a project. Populate it afterwards with add_llmobs_dataset_records.Name-idempotent within the project: an existing dataset of the same name is returned with already_existed=true and nothing is created — say so rather than reporting a new dataset.Returns dataset (including the UUID the record tools need) and already_existed. On invalid input or API failure returns a DatasetRecordToolError with reason + recovery_hint.To start from an existing dataset’s records instead of an empty one, use clone_llmobs_dataset.Input Parameters
Create llmobs experiment
Create llmobs experiment
DATADOG_MCP_CREATE_LLMOBS_EXPERIMENTCreate a new LLM Observability experiment object in a project. This records the experiment (so events/metrics can be reported against it) and does NOT run any model inference — it is the create counterpart of update_llmobs_experiment.To run a prompt template against a dataset and evaluate the results, use launch_llmobs_experiment instead.Required inputs: project_id and experiment_name.Returns the created experiment_id and its resolved name (the backend may append a suffix to keep the run name unique). Use submit_llmobs_experiment_events to attach evaluation metrics, or update_llmobs_experiment to change its properties.Input Parameters
Create llmobs project
Create llmobs project
DATADOG_MCP_CREATE_LLMOBS_PROJECTCreate an LLM Observability experiments project — the container that owns datasets and experiments.Name-idempotent: if a project with this name already exists in the org, it is returned with already_existed=true and nothing is created. Report that back rather than claiming a new project was made.Returns project (with the UUID needed by create_llmobs_dataset, list_llmobs_datasets, and list_llmobs_experiments) and already_existed.Check list_llmobs_projects first when the user may be describing a project that already exists under a different name.Input Parameters
Create-onboarding-flag
Create-onboarding-flag
DATADOG_MCP_CREATE_ONBOARDING_FLAGCreate the onboarding proof flag: a predictable boolean flag (disabled=false, enabled=true; default disabled) with a catch-all FEATURE_GATE allocation serving enabled=true in the selected NON-PRODUCTION environment, tagged source:agentic-onboarding.Safety gates enforced by this tool (not by the agent): the environment must resolve, must NOT be production, must NOT require feature-flag approval, and its queries must cover dd_env under the runtime matcher. It refuses to write unless confirm is true — call it first with confirm:false (or omitted) to get the exact write preview, show that to the user, then call again with confirm:true.Input Parameters
Create or update llmobs evaluator
Create or update llmobs evaluator
DATADOG_MCP_CREATE_OR_UPDATE_LLMOBS_EVALUATORCreate or update an LLM-judge evaluator configuration.This is a full replace, not a patch. The persisted evaluator becomes exactly what you send: any field you omit is reset to its default (or unset), even if the existing evaluator had a value. Before updating an existing evaluator, always call get_llmobs_evaluator first and re-send every field you want to keep alongside whatever you’re changing — otherwise you will silently clobber prompt_template, output_schema, sampling, etc.Targets a specific ml_app and optionally a filter / sampling percentage. Provide the judge’s model + prompt_template to define how it scores each span. Returns the resulting (post-write) configuration on success.Required: eval_name, application_name, enabled, integration_provider, model_name, prompt_template, parsing_type, output_schema.Common optional fields: temperature (defaults to 0), max_tokens (defaults to 4096), sampling_percentage (0, 100], eval_scope (span | trace | session), vertex_ai_project / vertex_ai_location (for Vertex AI), bedrock_region or bedrock_inference_profile (for Bedrock), assessment_criteria.Input Parameters
const entries — extend that list to add or remove a label. Required when parsing_type is ‘structured_output’ or ‘json’.Create reference table
Create reference table
DATADOG_MCP_CREATE_REFERENCE_TABLECreate a new reference table. Supports two modes: (1) LOCAL_FILE — creates an empty table with no cloud backing; rows are added later via upsert_reference_table_rows or append_reference_table_rows. (2) Cloud-backed (S3, GCS, AZURE) — syncs from a CSV file stored in a cloud bucket. Only INT32 and STRING field types are supported.Input Parameters
Create rum operation
Create rum operation
DATADOG_MCP_CREATE_RUM_OPERATIONCreate a web-UI-configured RUM operation: the same object created by clicking “Create Operation” in the RUM Operations UI. An operation tracks a user journey (e.g. checkout) between a start event and a success, failure, or abandonment event, matched by search queries against RUM events.This tool does NOT create SDK-instrumented operations — those are defined in application code via startFeatureOperation(…) and have no backend object; this tool cannot create or affect them. For SDK-instrumented operations, load the datadog/rum skill (load_datadog_skill) for the SDK instrumentation guidance — this tool only configures web-UI operations. Use this tool only when the ask is to configure an operation from the RUM Operations UI’s perspective (e.g. “set up an operation for checkout using these queries”), not “help me instrument my app’s code.”application_id scopes the operation to a RUM application and is required — find it with search_rum_applications. Before writing a query from a free-text description of a user journey, use search_datadog_rum_events to confirm the real facet values (view names, action names, URL paths) rather than guessing them. An operation name must be unique; the backend rejects a duplicate (409), so the create call itself surfaces a name conflict — a pre-check via search_rum_operations is optional, not required.Each of start/success/failure requires a query (<step>_query + <step>_event_type). The “update” step type is a UI-only feature this tool does not expose. abandonment requires start_query to target exactly one view via @view.name: (see its description) — the tool rejects the call otherwise. If the user asks to track abandonment or drop-off, set abandonment: true (requires start_query to target exactly one view). Every step query must carry the facets its event type requires (see start_query), and @view.name: may never be a bare wildcard (”*”). category — including the default, component_loading — restricts which event types are valid per step (see category); a view start is only valid under page_load, page_navigation, custom, or custom_operation (never under component_loading or form_submission), and a view success is only valid under page_navigation, form_submission, custom, or custom_operation (never under component_loading or page_load). A failure step never accepts view, under any category.Example — “track checkout as an operation, from the checkout page to order confirmation, failing on a declined payment”: call with name=“checkout”, category=“page_navigation”, start_query=“@view.name:/checkout”, start_event_type=“view”, success_query=“@view.name:/checkout/complete”, success_event_type=“view”, failure_query=“@view.name:/checkout @error.message:declined”, failure_event_type=“error”, application_id=“<uuid from search_rum_applications>”, confirm=true.Always confirm the exact operation (name, queries, event types) with the user before calling. Never create an operation speculatively. Re-invoke with confirm: true once confirmed.Input Parameters
Create-saved-filter
Create-saved-filter
Cws agent events schema
Cws agent events schema
DATADOG_MCP_CWS_AGENT_EVENTS_SCHEMAGet the schema (available fields) for Workload Protection agent events — the raw runtime security events (process, file, network, and DNS activity) collected by the Datadog Agent. Workload Protection is also known as Cloud Workload Security (CWS) or CSM Threats; “runtime security” and “agent events” refer to the same data. Use this tool to discover what fields can be used to filter or query agent events before running an agent events search. Returns field names, types, and optionally descriptions and enum values.Input Parameters
dd gff
dd gff
DATADOG_MCP__DD_GFFdo-not-calldd guc
dd guc
DATADOG_MCP__DD_GUCdo-not-calldd rfw
dd rfw
DATADOG_MCP__DD_RFWdo-not-callDdsql create link
Ddsql create link
Ddsql get spec
Ddsql get spec
DATADOG_MCP_DDSQL_GET_SPECGet a compact DDSQL capability spec with supported SQL functions, SQL keywords, and DDSQL-specific deltas from vanilla PostgreSQL. Start with this tool before composing queries, then use ddsql_schema_search_tables and ddsql_schema_get_table_columns for schema discovery.Input Parameters
Ddsql read saved query
Ddsql read saved query
Ddsql run query
Ddsql run query
DATADOG_MCP_DDSQL_RUN_QUERYRun a DDSQL query and return results. Recommended flow: (1) call ddsql_get_spec, (2) call ddsql_schema_search_tables, (3) for data tables use entries in tables: if searchable=true, call ddsql_schema_search_unstructured_fields first and fall back to ddsql_schema_get_table_columns; if searchable=false, call ddsql_schema_get_table_columns, (4) for metrics use entries in metrics: each item is a metric name (for example system.cpu.user); use that name in meta.metrics_query_format_doc examples to build dd.metrics_scalar(…) or dd.metrics_timeseries(…), then execute ddsql_run_query.Input Parameters
Ddsql schema get table columns
Ddsql schema get table columns
DATADOG_MCP_DDSQL_SCHEMA_GET_TABLE_COLUMNSGet static SQL columns for a DDSQL table from schema metadata. Use this after ddsql_schema_search_tables for entries in tables where searchable=false, or as fallback when ddsql_schema_search_unstructured_fields is unavailable for searchable entries. Returns compact column metadata: name, ddsql_type (SQL-layer type — use for DDSQL queries and PTF AS(column TYPE) casts), and analysis_type (structured-output type — use for advanced_query structured output, never in SQL).Input Parameters
Ddsql schema search tables
Ddsql schema search tables
DATADOG_MCP_DDSQL_SCHEMA_SEARCH_TABLESSearch DDSQL datasets across four providers: public tables, reference tables, metrics, and published analyses. Results are returned in three TSV sections: tables (public + reference_tables), metrics, and published_analyses. Each table, metrics, or published_analyses row includes a searchable flag: for searchable=true entries, try ddsql_schema_search_unstructured_fields first to discover dynamic unstructured fields, then fall back to ddsql_schema_get_table_columns for static columns. For searchable=false entries, use ddsql_schema_get_table_columns directly. Use per-provider limits and offsets to control result size and paginate through results. Setting a provider’s limit to 0 will skip it and return an empty set result. When the call is successful, response metadata includes total_matching and truncated fields per provider to guide follow-up pagination calls. For published_analyses rows, the id field is the FQDN in published_analyses.<encoded-id> form — pass it as-is to ddsql_schema_get_table_columns, but strip the published_analyses. prefix when using it as dataset_id in a notebook cell datasource definition.Input Parameters
Ddsql schema search unstructured fields
Ddsql schema search unstructured fields
DATADOG_MCP_DDSQL_SCHEMA_SEARCH_UNSTRUCTURED_FIELDSSearch and rank fields for an unstructured DDSQL source. Use this after ddsql_schema_search_tables for entries where searchable=true as the primary schema-discovery path; results include both common static and dynamic fields. If unavailable, fall back to ddsql_schema_get_table_columns. Returns compact field metadata sorted by frequency: name, ddsql_type (SQL-layer type — use for PTF AS(column TYPE) casts and all DDSQL queries), and analysis_type (structured-output type — use for advanced_query structured output, never in SQL). Also returns source-specific PTF query guidance when available. Supports optional pagination via offset (default 0) and limit (default 10, max 100) parameters. Pass limit=0 to skip the field search and retrieve only PTF query guidance; the response will include fetched=false and omit total_available and truncated metadata. The optional query parameter uses EVP key:value filters (for example service:foo), where keys correspond to fields returned by this API.Input Parameters
Ddsql search saved queries
Ddsql search saved queries
DATADOG_MCP_DDSQL_SEARCH_SAVED_QUERIESSearch and list saved DDSQL queries. Use to find existing saved queries by name or description. Results are sorted by most recently modified and include query ID, name, SQL text, columns, visibility, description and author/timestamp metadata. Supports optional text filtering and pagination.Input Parameters
Ddsql upsert saved query
Ddsql upsert saved query
DATADOG_MCP_DDSQL_UPSERT_SAVED_QUERYCreate or update a saved DDSQL query. To create a new query, provide name and query without query_id — if the user has not specified a name, generate a concise descriptive name based on the query content before calling this tool. To update an existing query, provide query_id together with name and/or query; for partial updates, missing fields are preserved from the existing record. Returns the full saved query record on success. Any other combination of inputs returns an error.Input Parameters
Delete datadog dashboard
Delete datadog dashboard
Delete datadog published analysis
Delete datadog published analysis
Delete datadog security aap custom rule
Delete datadog security aap custom rule
DATADOG_MCP_DELETE_DATADOG_SECURITY_AAP_CUSTOM_RULEDelete an AAP (App & API Protection) WAF custom rule by id. Works for any custom rule (blocking, monitoring, or trace-tagging — one rule space). IRREVERSIBLE: the rule cannot be restored, only re-created. Only call when the user clearly wants the rule gone.Call get_datadog_security_aap_custom_rules first to confirm the id.To stop a rule without deleting it, use upsert_datadog_security_aap_custom_rule with status=“disabled” instead.NOT the passlist (WAF exceptions) or denylist (blocked IPs/users), and NOT Cloud SIEM detection rules.Keywords: AAP, ASM, WAF, custom rule, delete, remove, drop, in-app WAF rule.Input Parameters
Delete datadog security detection rules
Delete datadog security detection rules
DATADOG_MCP_DELETE_DATADOG_SECURITY_DETECTION_RULESDelete one or more Cloud SIEM detection rules by ID. Only custom (non-default) rules can be deleted — default rules return 403. Each rule is authorised individually; rules the caller cannot edit appear in failed_rules without aborting the rest of the batch. Returns deleted_rules (successfully deleted IDs) and failed_rules (IDs that could not be deleted).Input Parameters
Delete datadog security findings automation rule
Delete datadog security findings automation rule
Delete datadog security suppression
Delete datadog security suppression
DATADOG_MCP_DELETE_DATADOG_SECURITY_SUPPRESSIONDelete a security monitoring suppression rule in Datadog. This operation is irreversible: the suppression is removed immediately and cannot be restored. Call get_datadog_security_suppressions first to confirm the correct suppression will be deleted.Input Parameters
Delete datadog security trace passlist
Delete datadog security trace passlist
DATADOG_MCP_DELETE_DATADOG_SECURITY_TRACE_PASSLISTDelete an AAP (App & API Protection) passlist/allowlist entry — also known as a WAF exclusion filter — by exclusion_filter_id. IRREVERSIBLE: the entry cannot be restored, only re-created. AAP traces only; unrelated to Cloud SIEM signal suppression.Use this tool when a user asks to exclude/exempt WAF traces, drop an AAP allowlist entry, or remove a passlist/exclusion filter.Call get_datadog_security_trace_passlist first to confirm the right exclusion_filter_id.To disable an entry without deleting it, use upsert_datadog_security_trace_passlist with action=“update” and enabled=false instead.Keywords: AAP, ASM, passlist, allowlist, exclusion filter, exclude WAF traces, remove, drop, WAF exception.Input Parameters
Delete datadog skill
Delete datadog skill
DATADOG_MCP_DELETE_DATADOG_SKILLDelete one of your own library skills from your organization’s Skills Library — a separate, user-authored set of task guides, distinct from any built-in “Skills” your own agent tooling may already have, and distinct from Datadog’s own first-party skills (a separate, built-in set you cannot edit through this tool). The library skill is identified by slug. Only library skills you authored that are private can be deleted; Shared (public) library skills cannot be deleted through this tool. If this returns a “not found” result, the library skill may not exist, or it may be Shared rather than your own private one — Shared library skills must be managed in the Datadog UI. This permanently deletes the library skill, so only call it after the user has explicitly confirmed the deletion.Input Parameters
Delete datadog spreadsheet
Delete datadog spreadsheet
DATADOG_MCP_DELETE_DATADOG_SPREADSHEETPermanently delete a Datadog spreadsheet by ID. This action is irreversible.Input Parameters
Delete datadog workflow
Delete datadog workflow
DATADOG_MCP_DELETE_DATADOG_WORKFLOWDelete a Datadog Workflow Automation workflow by ID. On success, the result contains deleted: true and the deleted workflowId. Always confirm with the user before invoking. Requires confirm: true.Input Parameters
true to actually delete the workflow. Acts as a safety gate — do not set to true unless the user has explicitly confirmed they want to permanently delete this workflow. The tool refuses the call when this is false or absent.Delete data observability monitor annotations
Delete data observability monitor annotations
DATADOG_MCP_DELETE_DATA_OBSERVABILITY_MONITOR_ANNOTATIONSDelete Data Quality monitor annotations by id.Monitor IDs are stable request identifiers, but when a monitor name has already been resolved, use the name as the primary user-facing label and put the ID in parentheses. Never mention group_hash when it is “0”; that is the default ungrouped series.Always call with dry_run true first to preview the exact annotations that will be deleted. Call again with dry_run false only after the preview is correct.Input Parameters
Delete llmobs annotation queue
Delete llmobs annotation queue
DATADOG_MCP_DELETE_LLMOBS_ANNOTATION_QUEUEPermanently delete an annotation queue and everything in it — its queued interactions and all human review labels recorded on them. Automations that feed the queue are detached.This cannot be undone, and the review work is not recoverable. Confirm with the user before calling, and if the labels are worth keeping, export them first by reading get_llmobs_annotated_interactions.To take interactions out of a queue while keeping the queue, use delete_llmobs_annotation_queue_interactions instead.Input Parameters
Delete llmobs annotation queue interactions
Delete llmobs annotation queue interactions
DATADOG_MCP_DELETE_LLMOBS_ANNOTATION_QUEUE_INTERACTIONSRemove interactions from an annotation queue. The annotations recorded on them are deleted too — this discards review work, not just the queue entry. The underlying traces and spans are untouched.All-or-nothing: one unknown id fails the whole batch and nothing is removed.To delete only the labels and leave the items queued for re-review, use delete_llmobs_annotations instead.Input Parameters
Delete llmobs annotations
Delete llmobs annotations
DATADOG_MCP_DELETE_LLMOBS_ANNOTATIONSDelete annotations from a queue, discarding those review labels. The interactions stay queued and can be re-annotated.Best-effort per id: returns deleted_annotation_ids for what was removed and errors for ids that were unknown or belonged to another queue — check both.Deleting someone else’s annotation destroys their review work; confirm with the user before removing annotations you did not write.Input Parameters
Delete llmobs evaluator
Delete llmobs evaluator
Delete llmobs experiments
Delete llmobs experiments
DATADOG_MCP_DELETE_LLMOBS_EXPERIMENTSDelete experiment runs by ID. The runs and their events stop appearing in LLM Observability.Two-step: PREVIEW (confirmed=false) → DELETE (confirmed=true).confirmed=false: deletes nothing. Withproject_id(ordataset_id) it resolves each ID to its experiment name and returns them alongside anyunresolved_ids; without a scope it setsname_resolution_skippedand returns IDs only. Pass the scope so the user approves names rather than bare UUIDs. Show theconfirmation_promptand get explicit approval.confirmed=true: issues the delete. Do not retry a successful call.
unresolved_id is not proof the experiment is gone — it may sit outside the scope you passed — so delete on it still applies.Resolve IDs with list_llmobs_experiments first, and never infer them from an experiment name yourself. At most 50 experiments per call.Input Parameters
Delete rum metric
Delete rum metric
DATADOG_MCP_DELETE_RUM_METRICDelete a RUM custom metric by ID. Permanent and cannot be undone. Only custom metrics can be deleted (not OOTB metrics). Always confirm the deletion with the user before calling. Never delete a metric speculatively. Use search_rum_metrics with type=custom to confirm the metric exists first.Input Parameters
Delete rum operation
Delete rum operation
DATADOG_MCP_DELETE_RUM_OPERATIONPermanently delete a web-UI-configured RUM operation: the same object deleted by removing an operation in the RUM Operations UI. Identify it by operation_id (preferred) or name.This tool does NOT affect SDK-instrumented operations — those are defined in application code via startFeatureOperation(…) and have no backend object; this tool cannot delete or otherwise affect them. For SDK-instrumented operations, load the datadog/rum skill (load_datadog_skill) for the SDK instrumentation guidance — this tool only deletes web-UI-configured operations.This is permanent and cannot be undone. Always confirm the exact operation (id or name) with the user before calling. Never delete an operation speculatively. Re-invoke with confirm: true once confirmed.The response echoes the deleted operation’s resolved operation_id and name — when deleting by name, the match is case-insensitive and whitespace-trimmed, so the resolved name may differ from the literal name passed in; report the resolved value to the user, not the input.The response also includes warnings listing any SLOs or monitors still tagged feature_operation:<name> for this operation, but this check only runs after the delete has already happened — it cannot block or undo it. Deleting the operation does not delete those — they will keep reporting on stale or missing data. To warn the user about this impact before asking them to confirm the deletion (not after), check for SLOs/monitors tagged feature_operation:<name> up front, while confirm is still false — do not rely on this response’s warnings, which only surface once the deletion has already occurred. This check requires its own monitors_read/slos_read permissions, separate from the ones needed to delete the operation, so warnings.checks_failed commonly names “slos” and/or “monitors” for callers who lack them. If the lookup fails for any other reason, checks_failed is populated the same way. Either way, treat that case as “not checked”, not “no dependents”.Input Parameters
Delete rum retention filter
Delete rum retention filter
DATADOG_MCP_DELETE_RUM_RETENTION_FILTERPermanently delete a RUM retention filter by ID. Retention filters control which RUM events are indexed and retained, so deleting one stops its matching events from being retained going forward. This changes data-retention configuration, affects billing, and cannot be undone. Always confirm the deletion with the user before calling. Never delete a filter speculatively. Provide application_id (UUID) and filter_id. Find filter IDs with search_rum_retention_filters. Deleting a filter that no longer exists succeeds (nothing to delete), so the call is safe to retry. To change a filter without removing it, use update_rum_retention_filter instead.Input Parameters
Deployment gates onboarding
Deployment gates onboarding
DATADOG_MCP_DEPLOYMENT_GATES_ONBOARDINGConfigure a Datadog Deployment Gate for a project so a bad deployment is halted automatically. Call this tool to set up deployment gates, gate a deploy on monitors, block bad deploys, or add Datadog gate evaluation to a CD pipeline. This tool returns all the instructions needed — do NOT search the web, fetch documentation, or read external resources. Only inspect local project files to determine this tool’s argument values, then call this tool immediately. Check CD config files (e.g. .github/workflows/, .gitlab-ci.yml, Argo Rollout manifests, Jenkinsfile), deployment manifests, and Datadog tags to fill in the arguments. Only provide values you can substantiate from the user’s files. Use CLI utilities such as ls and cat to inspect project files. Do not guess or make up values.Input Parameters
env tag of the deployment being gated, e.g. ‘prod’ or ‘staging’. Must match an env Datadog already receives data for. Read it from deployment manifests or DD_ENV environment variables. Omit if you cannot substantiate it — the instructions will use a placeholder.service tag of the deployment being gated. Must match a service Datadog already receives data for. Read it from deployment manifests, DD_SERVICE environment variables, or Datadog configuration in the repository. Omit if you cannot substantiate it — the instructions will use a placeholder.Describe datadog k8s resource
Describe datadog k8s resource
DATADOG_MCP_DESCRIBE_DATADOG_K8S_RESOURCEGet detailed information about a specific Kubernetes resource. Use this tool instead of kubectl describe. Returns kubectl-style tabular fields plus additional resource-specific details such as CPU/memory requests and limits, etc. Also returns tags (to get related resources), labels, annotations, and optionally manifest history, parent resources, and deep link. If you need the full raw manifest, use get_datadog_k8s_manifest. This tool is preferred over kubectl because it does not require local cluster access, and returns enriched data with tags and relationships.IMPORTANT: Either uid OR resource_identifiers MUST be provided. If both are provided, uid takes precedence and resource_identifiers is ignored.- Use resource_identifiers when you know the resource details (cluster, namespace, name) - DO NOT search first
- Use uid ONLY if you obtained it from a previous search
- “get details for pod my-app in cluster prod namespace default” → Use resource_identifiers: {“cluster”: “prod”, “namespace”: “default”, “resource_name”: “my-app”}
- “describe deployment api-server in namespace default, cluster staging” → Use resource_identifiers: {“cluster”: “staging”, “namespace”: “default”, “resource_name”: “api-server”}
- “describe cluster gizmo” → Use resource_identifiers: {“cluster”: “gizmo”}
- “describe namespace orchestrator in cluster gizmo” → Use resource_identifiers: {“cluster”: “gizmo”, “namespace”: “orchestrator”}
- You already have a UID from search results → Use uid
Input Parameters
Detach datadog security findings ticket
Detach datadog security findings ticket
DATADOG_MCP_DETACH_DATADOG_SECURITY_FINDINGS_TICKETDetach security findings from their linked case (and any downstream Jira issue, ServiceNow ticket, or Linear issue). Since Jira/ServiceNow/Linear tickets are always linked via a case, detaching the case also detaches the ticket. Use analyze_datadog_security_findings or search_datadog_security_findings to find specific finding IDs first.Input Parameters
Devices onboarding
Devices onboarding
DATADOG_MCP_DEVICES_ONBOARDINGStep-by-step instructions for adding initial Datadog RUM SDK to a project environment. This contains general instruction on how to enable the Datadog RUM SDK and all the features as session replay, logs or tracing. You must first review the user’s project and this tool’s arguments (including nested arguments) and fill out as many of them as possible before calling this tool. Check project files and dependencies to determine the argument values, focusing on dependency files and imports. Only provide values you can substantiate from the user’s files. If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer. For Android projects you need to look deeper into the project to determine if the project is using Jetpack Compose or not. In case of doubt, return ‘android-views’. Before calling this tool, you must first check if the user’s project has already been configured for Datadog. If it has, you should not call this tool.Input Parameters
Diff network device configurations
Diff network device configurations
DATADOG_MCP_DIFF_NETWORK_DEVICE_CONFIGURATIONSCompare two ndm network device configuration snapshots and return a unified diff.Inputs:- original_config_id (required)
- modified_config_id (required)
Input Parameters
Docker onboarding
Docker onboarding
DATADOG_MCP_DOCKER_ONBOARDINGInstalls and configures the Datadog Agent container to collect infrastructure metrics, container telemetry, APM traces, and logs. The agent runs as a Docker container alongside any workload on a Docker-enabled host. You must first review the user’s project and this tool’s arguments and fill out as many of them as possible before calling this tool. Check project files (Dockerfile, docker-compose.yaml, requirements.txt, etc.) to determine argument values. Only provide values you can substantiate from the user’s files. Before calling this tool, check if the project has already been configured for Datadog — if it has, do not call this tool.Input Parameters
Do not call refresh widget
Do not call refresh widget
DATADOG_MCP_DO_NOT_CALL_REFRESH_WIDGETdo-not-callEcs onboarding
Ecs onboarding
DATADOG_MCP_ECS_ONBOARDINGStep-by-step instructions for adding initial Datadog Observability setup to ECS applications and configurations. You must first review the user’s project and this tool’s arguments (including any nested arguments) and fill out as many of them as possible before calling this tool. Check project files and dependencies to determine the argument values, focusing on dependency files and imports. Only provide values you can substantiate from the user’s files. If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer. Before calling this tool, you must first check if the user’s project has already been configured for Datadog. If it has, you should further check if the project has already been configured for ECS. If it has, you should not call this tool. Use CLI utilities, such as ls and cat when checking if the project contains existing env files and viewing their contents, respectively.Input Parameters
Edit datadog notebook
Edit datadog notebook
DATADOG_MCP_EDIT_DATADOG_NOTEBOOKEdits an existing notebook. Can edit cells, metadata (name, template_variables, tags), or both. Look up widget reference schemas before constructing graph cells. Cell modes: (1) Full-replace (default) — replaces all cells; destroys existing comment marks. (2) Append (append_only=true) — adds cells to the end; preserves comment marks. To edit only metadata, omit the cells parameter and provide at least one of name/template_variables/tags. Metadata edits are done on a best effort basis and can be combined with either cell mode.Input Parameters
Edit global variables
Edit global variables
DATADOG_MCP_EDIT_GLOBAL_VARIABLESPartially edit a Synthetics global variable by id. Only name, description, tags (full array replace), and value (value + secure) are editable. Omitted fields are left unchanged; only the fields explicitly set in this call are updated. parse_test_options, parse_test_public_id, and restricted_roles are not editable with this tool.Input Parameters
Edit synthetics tests
Edit synthetics tests
DATADOG_MCP_EDIT_SYNTHETICS_TESTSEdit the configuration of a Synthetics test. Use this tool to update the configuration of a test.Input Parameters
CREATE or DELETE operations. Any tag not referenced in the list will be kept as is. Can be an empty array if no tag update is needed.CREATE or DELETE operations. Any location not referenced in the list will be kept as is. Can be an empty array if no location update is needed.CREATE, or DELETE operations. Any assertion not referenced in the list will be kept as is. Can be an empty array if no assertion update is needed.assertionUpdate, locationUpdate and tagsUpdate parameters and MUST NOT be passed here. Can be an empty object if no update is needed.Execute code
Execute code
DATADOG_MCP_EXECUTE_CODEExecute JavaScript in a sandbox with access to Datadog through the official TypeScript-SDK-shaped API and explicitly enabled code-exec extensions.Quick start:dd global only exposes dd.time.*. Product APIs are not mounted under dd; import official APIs from @datadog/datadog-api-client and construct the appropriate v1 or v2 API class as shown above. Reviewed APIs that are not in the official SDK are exposed separately through the sandbox-only @datadog/code-exec package when enabled for the current session.Datadog APIs are available through both the official TypeScript SDK and enabled code-exec extensions. Code-exec’s value is that you can compose API calls in one script, join data across products, and return a compact result — not that you need a separate MCP helper for each Datadog query.SDK discovery requirement: Do not rely on model memory for Datadog SDK method names, request fields, enum values, or response shapes. Before calling execute_code, call the separate search_datadog_sdk MCP tool unless the exact operation and complete request shape are already present in a known-good example below or were returned by an earlier SDK search in this conversation. If execute_code returns invalid_request, an unknown method or member error, or a request-shape error, call search_datadog_sdk before retrying. Do not repair these errors by guessing fields. Its metadata-only catalog only returns official SDK methods and code-exec extensions available in the current execute_code session. In one JavaScript program, select the operation and return its usageNotes plus a bounded closure of its typeRefs from catalog.types. For official SDK operations, use the declared version, API, method, and TypeScript types. For extensions, use the declared module, export, method, and TypeScript types. Do not guess fields from an HTTP path or summary.For non-trivial investigations where you need a multi-query script, API aggregation, cross-source joins, or compact ranked output, load the datadog/code-exec skill before writing the script. Skip it for trivial one-liners or when the exact request shape is already clear. Code-exec guidance lives in datadog/code-exec and its bundled references; don’t guess product-specific skill names like datadog/traces or datadog/metrics from the task topic.Execution discipline
dd.time.*returns RFC3339 strings. Logs and spans accept those strings directly. Metrics scalar and timeseries requests require Unix milliseconds; useDate.parse(dd.time.hoursAgo(...))andDate.parse(dd.time.now()), and do not hand-calculate Unix timestamps.- After an
invalid_request, re-check the operation signature, type declarations, and usage notes before retrying. Verify timestamp units, enum values, and exact camelCase property names. - Compose related queries in one script and return a compact result. Use
Promise.allwhen every result is required. When independent calls can still provide useful evidence if a sibling fails, usePromise.allSettledand return the successful evidence alongside a compact failures array.
execute_code reports outcome: "partial" and partial: true; the returned value remains usable, and diagnostics.api_calls describes the failed calls. Treat partial evidence as incomplete and retry only the missing source when it is necessary for the answer. If every API call fails, the execution is still reported as a failure even if the script caught the rejections.Investigation rules
- Use aggregate APIs for totals, top-Ns, rankings, ratios, and percentiles. Prefer aggregate operations where supported. Do not group returned samples and present them as global rankings.
- For top-N aggregations, put the sort on the
groupByentry. Alimitwithoutsortdoes not guarantee the first bucket is the top bucket. - For log facet rankings, use
v2.LogsApi.aggregateLogs. Group by facets such as@error.kind,@http.status_code,@http.route, or@duration. - For span rankings, use
v2.SpansApi.aggregateSpans. Usev2.SpansApi, notv2.TracesApi, for span search and aggregation. - For metric totals, grouped metric rows, or APM metrics, use
v2.MetricsApi.queryScalarData; usequeryTimeseriesDatawhen the answer needs points over time. Scalar responses are columnar underresult.data.attributes.columns, notattributes.seriesorattributes.values. - When the user names a data source — metrics, logs, or spans/traces — use an operation for that source unless the task explicitly asks to compare sources.
- If the user asks for operation name, group spans by
operation_name. If the user asks for endpoint, resource, route, or path, group spans byresource_name. - For APM error spans, use
status:errorunless you’ve verified another facet. Do not assumeerror:trueworks. - For HTTP status code filters, use attributes:
@http.status_code:[400 TO 599]or@http.status_code:[500 TO 599], notstatus:4xx/status:5xx. - Span reserved fields don’t use
@:service,status,resource_name,operation_name,trace_id,type. Span duration is@durationin nanoseconds; p95 span aggregation usespc95over@duration.
Known-good SDK examples
Find source repositories for a service
When you need source code for a service found in telemetry, query its Service Catalog definition. Repository metadata may be represented asrepos, repo-typed links, or the definition’s GitHub source URL depending on the schema version.Investigate a Synthetics failure against a passing baseline
Use the v2 result APIs to compare the initial failure with the most recent passing run from the same location and browser device. The result summary’s event ID is required for reliable full-result retrieval.traces.getTrace code-exec extension in the same script. If the result version changed but the executed step evidence is inconclusive, use getSyntheticsTestVersion to compare retained configurations.Top log error kind
Top span operation or resource
compute: [{ aggregation: "pc95", metric: "@duration" }] and read bucket.attributes.compute.c0.JavaScript and imports
Code-exec runs JavaScript, not TypeScript: type annotations likeconst params: v2.LogsApiAggregateLogsRequest = ... won’t parse. Request objects, class names, method names, and imports follow the declarations returned by the API catalog, but the code itself should be plain JavaScript.The official Datadog SDK and enabled extension virtual packages are resolved inside the sandbox. Use the exact extension import returned by the API catalog rather than assuming a namespace:console.log/info/warn/error for intermediate output. Keep returned values small: aggregate rows, counts, and selected fields rather than raw API envelopes or broad samples. For paginated search and list APIs, follow response cursors when completeness matters; otherwise return a bounded page and label it as partial.Top-level await is supported. Optional timeout is in seconds (1–180, default 60); raise it for slower aggregate queries.Sandbox utilities
The only publicdd.* utilities are time helpers:Input Parameters
Execute datadog workflow
Execute datadog workflow
DATADOG_MCP_EXECUTE_DATADOG_WORKFLOWStart a new execution instance for a Datadog Workflow Automation workflow by ID. The workflow may be published or unpublished, and the selected base or draft spec must have an ‘agent’ trigger. Each successful call starts a distinct run and returns workflowId, instanceId, and URL. It does not wait for completion.If the selected spec lacks an agent trigger, use get_datadog_workflow and update_datadog_workflow to preserve the complete spec while adding one with the intended startStepNames, then execute the resulting draft. Do not publish the draft unless requested.Workflow actions can modify external systems; confirm with the user before invoking.Use list_datadog_workflow_instances or get_datadog_workflow_instance afterward only when runtime status, failure details, or outputs are needed.Input Parameters
Expand llmobs spans
Expand llmobs spans
DATADOG_MCP_EXPAND_LLMOBS_SPANSLoad the children of specific spans in a trace, enabling progressive tree exploration. Use this when get_llmobs_trace returns collapsed nodes you want to expand.Returns expanded_spans[] (recursive tree, each node with span_id, name, kind, status, duration_ms, content indicators like has_input/has_output, and nested children). Set max_depth to control how many levels deep to load (1–3).Input Parameters
Explore profiling call graph
Explore profiling call graph
DATADOG_MCP_EXPLORE_PROFILING_CALL_GRAPHExplore a call graph to identify hot call relationships for the provided profile type. Best suited for investigating a single service at a time. For cross-service comparisons, use get_profiling_timeseries.Things of note:- Provide traceContext OR scope by service via queryString (e.g. service:my-svc).
- Nodes represent frames/functions and edges represent call relationships (caller -> callee)
- sortedNodes is ordered by self value; use node id and edge targetId to link nodes
- Defaults: top 20 nodes, 5% cumulative cutoff, top 5 edges per node
- Use get_profiling_tag_names/get_profiling_tag_values to discover available tags and their values for filtering in queryString. Syntax: tag:value pairs separated by spaces (implicit AND), tag:(v1 OR v2) for alternatives, -tag:value for negation, tag:prefix* for wildcards.
- Always tell the user what time range was used unless it was explicitly specified in the request.
- For Chrome profiles (family:chrome in filter.query):
- Endpoint: append @view.name:<endpoint> to queryString.
- RUM event IDs (view, vital, action, long task, error): append @<type>.id:<id> to queryString (e.g. @action.id:x, or @action.id:(x OR y) for multiple).
Input Parameters
Explore profiling flame graph
Explore profiling flame graph
DATADOG_MCP_EXPLORE_PROFILING_FLAME_GRAPHObtain a list of top stacktraces based on their value contribution for the provided profile type. Best suited for investigating a single service at a time. For cross-service comparisons, use get_profiling_timeseries.Things of note:- Pay special attention to mentions of endpoints, attributes or stacktrace fields in the request. This tool supports filtering to those fields for more specific queries.
- Provide traceContext OR scope by service via queryString (e.g. service:my-svc).
- Stacktrace frames are ordered from caller to callee, with the more specific frame being the last in the list.
- For Chrome profiles (family:chrome in filter.query):
- Endpoint: append @view.name:<endpoint> to queryString and set endpointRegexFilter to the endpoint value.
- RUM event IDs (view, vital, action, long task, error): append @<type>.id:<id> to queryString (e.g. @action.id:x, or @action.id:(x OR y) for multiple), and set attribute + attributeRegexFilter to the corresponding profile attribute name and id value. Note: profile attribute names differ from queryString field names (e.g. attribute=action_id vs @action.id).
- Use get_profiling_tag_names/get_profiling_tag_values to discover available tags and their values for filtering in queryString. Syntax: tag:value pairs separated by spaces (implicit AND), tag:(v1 OR v2) for alternatives, -tag:value for negation, tag:prefix* for wildcards.
- Always tell the user what time range was used unless it was explicitly specified in the request.
Input Parameters
Explore profiling rum flamegraph
Explore profiling rum flamegraph
DATADOG_MCP_EXPLORE_PROFILING_RUM_FLAMEGRAPHReturns a flamegraph for profiles scoped to RUM events matching a given metric and optional filter. Works with any RUM-instrumented platform (browser, mobile, etc.) — use the family and service that match the instrumented application. Use this tool when the user asks which functions are responsible for a slow RUM metric (e.g. INP, LCP, time spent on a page, long tasks). Do NOT use explore_profiling_flame_graph for RUM metrics — it does not understand RUM event types and will produce wrong results.How it works:- You provide rumMetric and optionally rumQuery to scope which RUM events are considered.
- The backend resolves the matching RUM event IDs server-side and fetches the associated profiles.
- Flamegraph values are scaled per RUM event (average contribution per event), so results are comparable across different time windows and query scopes.
- Optional. Scopes which RUM events are included (e.g. “@view.name:/profiling/explorer”).
- Field prefixes must match the event type from the table above. Mixing prefixes from different event types returns an error.
- @profiling.has_profile:true is appended automatically — do not include it.
- Always report the time range and rumMetric used in your response.
Input Parameters
Explore profiling timeline
Explore profiling timeline
DATADOG_MCP_EXPLORE_PROFILING_TIMELINEAnalyze timeline activity showing lane groups (threads, GC, etc.) and their CPU/I/O activities. Best suited for investigating a single service instance at a time. For cross-service comparisons, use get_profiling_timeseries. Use for general thread analysis, or enable critical path (traceContext only) to identify latency bottlenecks.Key points:- Provide runtimeId OR traceContext (required)
- Time values in nanoseconds. Example: 1700000000 ns = 1.7 seconds. 260000000 ns = 26 milliseconds.
- Use get_profiling_tag_names/get_profiling_tag_values to discover available tags and their values for filtering in queryString. Syntax: tag:value pairs separated by spaces (implicit AND), tag:(v1 OR v2) for alternatives, -tag:value for negation, tag:prefix* for wildcards.
- Response groups by lane groups, sorted by activity
- To discover event types: call without focusEventType, check ‘threadStates’ in response, then refine
- Quick overview: Set useCriticalPath=true to see only critical path events and top blocking periods
- Deep dive: First call with useCriticalPath=true, get blocking periods with startTime/endTime. Then call again with fromString/toString and useCriticalPath=false to zoom into that period.
Input Parameters
Find datadog database instances
Find datadog database instances
DATADOG_MCP_FIND_DATADOG_DATABASE_INSTANCESDiscover and rank database instances for DBM investigation. USE THIS TOOL FIRST before calling other DBM tools that require a database_instance parameter.This tool discovers database instances via trace/span correlation or tag matching, fetches telemetry for each instance, and uses LLM analysis to assess health and rank instances.Provide either:- trace_id and/or span_id from APM to find correlated database instances
- tags to find matching instances (key:value format, ANDed together)
- Both can be combined
Input Parameters
Find llmobs error spans
Find llmobs error spans
DATADOG_MCP_FIND_LLMOBS_ERROR_SPANSFind all error spans in a trace with propagation context. Returns error details, parent context, and whether errors propagated to child spans.Returns errors grouped by span kind, each with span_id, error message/type/stack, and propagation info. Use get_llmobs_span_content on an error span to see its full input/output.Input Parameters
Generate monitor message
Generate monitor message
Get active feature flags
Get active feature flags
DATADOG_MCP_GET_ACTIVE_FEATURE_FLAGSdo-not-callGet autonomous system status
Get autonomous system status
DATADOG_MCP_GET_AUTONOMOUS_SYSTEM_STATUSGet the health status of an autonomous system (AS) using Network Path data.Calls the Network Path aggregate endpoint to assess whether the AS has detected issues such as packet loss, latency spikes, or lowered visibility.Input:- asn: the autonomous system number, e.g. AS15169 or 15169 (both accepted)
- from / to: optional time window as Unix timestamps in milliseconds; to defaults to now, and from defaults to one hour before to
- <METADATA>: scope_type (always “autonomous_system”), scope_query (the search filter used), status (rolled-up ok / degraded / unknown), total, degraded (counts). notes appears only when no data was found for the AS in the requested window.
- <YAML_DATA>: a list of AS entries, each with asn, status (ok / degraded only — never “unknown”, which is rollup-only), issues (list of {code, count}, omitted when healthy), metric_values (always populated regardless of status, so it can also show the magnitude behind an ok result; individual current_value/baseline_value may be nil when that data is unavailable), metadata (name, domain, category, country_code), metrics (test_cardinality, country_count), and network_path_url (AS detail deep link).
- packet_count: volume of AS-attributed hop observations in the window — a traffic-volume/visibility proxy, NOT a count of dropped/lost packets despite the name, and not the same as the distinct test count (metrics.test_cardinality). Low current_value vs. baseline signals lowered_visibility (reduced visibility), not packet loss.
- destination_reachability_ratio: average fraction of packets that reached the destination; higher is better. Low current_value vs. baseline signals the packet_loss issue.
- avg_latency_ms: average round-trip latency in milliseconds; higher is worse. Elevated current_value vs. baseline signals the latency_spike issue.
- degraded: the AS is performing worse than its own ~7-day baseline on one or more dimensions (latency, packet loss, or test visibility). This is a relative signal — it does not mean the AS is objectively broken, only that it has regressed from its recent norm.
- ok: the AS was found with no detected regression vs its baseline
- unknown: no Network Path data found for this AS in the time window
- Check if a specific AS is currently healthy
- Identify what issues a degraded AS is experiencing
- Get a deep link to the Network Path autonomous systems page for the AS
Input Parameters
Get-canary-results
Get-canary-results
DATADOG_MCP_GET_CANARY_RESULTSGet results from completed or in-progress canary experiments for a feature flag. This tool retrieves experimental data showing how each variant performed during canary testing, including metric measurements, statistical significance, and traffic distribution. Use this when you need to:- Review the performance of a canary deployment
- Check if a canary rollout met its success criteria
- Analyze metric differences between variants in a canary test
- Understand why a canary was paused or aborted
- Allocation metadata (name, key, environment, creation time)
- Experiment status and state
- Variant performance metrics (assignment counts, metric means, statistical lift, confidence intervals)
- Guardrail metric information
Input Parameters
Get change stories
Get change stories
DATADOG_MCP_GET_CHANGE_STORIESRetrieve change events for an APM service over a time range. Use to correlate changes with performance issues, errors or incidents.Tracked Change types: deployment (code/version), feature_flag, traffic_anomaly, watchdog (Datadog anomaly detection), kubernetes (k8s deployment manifest updates), scale (manual k8s scale events), crashloopbackoff (k8s crashloops), database (DB schema or setting changes), schema (data stream schemas only; not DB/API schema), configuration (limited to specific tracked sources — absence does not imply no config changed)Input Parameters
Get data catalog schema
Get data catalog schema
DATADOG_MCP_GET_DATA_CATALOG_SCHEMAReturn the entity type schema for every platform this org has data in.Takes no arguments. Discovers active platforms by searching for root entities across all supported platform types, then returns the metaschema for each: entity types, containment hierarchy, and filterable attributes.Use this when you need to know:- Which platforms are available in the data catalog
- What entity types exist for each platform (e.g. “table”, “schema”, “column”, “dbt_model”)
- The containment hierarchy (e.g. account → database → schema → table → column)
- What attribute names can be used as filters in search_data_entities
- What metrics are available for a given entity type (e.g. row count, size, freshness for tables)
- entity_type: canonical entity type name to pass as entity_type in search_data_entities (e.g. “database_table”)
- display_name: human-readable label (e.g. “table”)
- children: display names of direct child entity types
- suggest_attributes: attribute names usable as filters in search_data_entities
- default_metrics: Datadog metrics emitted by default for this entity type. Use get_datadog_metric (if available) to query these by name. Metrics are scoped to a specific entity via tags such as entity_id, platform, account, database, schema, and table. Example: to get the row count for a specific table, query metric “dataset.record_count” filtered by its entity_id tag.
Input Parameters
Get datadog code coverage branch summary
Get datadog code coverage branch summary
DATADOG_MCP_GET_DATADOG_CODE_COVERAGE_BRANCH_SUMMARYFetch aggregated code coverage summary metrics for a repository branch. Use this tool to retrieve total coverage, patch coverage, and service/codeowner breakdowns for a specific branch.Common prompts: • Coverage summary for main: repository_url=https://github.com/org/repo branch=main • Coverage summary for release branch: repository_url=https://github.com/org/repo branch=release/1.xInput Parameters
Get datadog code coverage commit summary
Get datadog code coverage commit summary
DATADOG_MCP_GET_DATADOG_CODE_COVERAGE_COMMIT_SUMMARYFetch aggregated code coverage summary metrics for a repository commit. Use this tool to retrieve total coverage, patch coverage, and service/codeowner breakdowns for a specific commit.Common prompts: • Coverage summary for a commit: repository_url=https://github.com/org/repo commit_sha=<40-char sha>Input Parameters
Get datadog code coverage files
Get datadog code coverage files
DATADOG_MCP_GET_DATADOG_CODE_COVERAGE_FILESFetch per-file code coverage line data for a repository commit, branch, or pull request. Returns executable lines, covered lines, and added lines for each file. Use this tool to inspect which specific lines are covered or uncovered.Exactly one of commit_sha, branch, or pr_number must be provided. At most one of service, codeowner, or flag may be provided to filter results.Common prompts: • Per-file coverage for PR #123: repository_url=https://github.com/org/repo pr_number=123 • Changed-file coverage for a commit: repository_url=https://github.com/org/repo commit_sha=<40-char sha> changed_only=trueInput Parameters
Get datadog code coverage pr summary
Get datadog code coverage pr summary
DATADOG_MCP_GET_DATADOG_CODE_COVERAGE_PR_SUMMARYFetch aggregated code coverage summary metrics for a pull request. Use this tool to retrieve total coverage, patch coverage, and service/codeowner breakdowns for a specific pull request.Common prompts: • Coverage summary for PR #123: repository_url=https://github.com/org/repo pr_number=123Input Parameters
Get datadog dashboard
Get datadog dashboard
DATADOG_MCP_GET_DATADOG_DASHBOARDRetrieves a custom or integration Datadog dashboard by ID, returning its title, description, tags, widgets, and template variables. Use search_datadog_dashboards first to find dashboard IDs.Input Parameters
Get datadog database calling services
Get datadog database calling services
DATADOG_MCP_GET_DATADOG_DATABASE_CALLING_SERVICESIdentify upstream APM services and resources that call database queries. Use this tool to correlate database activity with application traces, enabling root cause analysis across the APM-database boundary. Returns the primary (most frequent) calling service and its associated resources.Input Parameters
Get datadog database explain plans
Get datadog database explain plans
DATADOG_MCP_GET_DATADOG_DATABASE_EXPLAIN_PLANSRetrieve explain plans for a query or plan signature within a timeframe. Returns simplified plan structures optimized for analysis, including operator trees, index usage, estimated costs, and temporal metadata (first seen, last seen, occurrence count). Plans are sorted by estimated cost in descending order. When you already know the plan signature, pass plan_signature — a query-signature-only search returns at most the 50 most frequent plans and can miss a target, especially EXPLAIN ANALYZE plans which vary more than generic explains. Note: For SQL Server stored procedures with multiple statements, the simplified_plan field describes the first statement only; additional statements in the procedure are not currently surfaced.Input Parameters
Get datadog database health signals
Get datadog database health signals
DATADOG_MCP_GET_DATADOG_DATABASE_HEALTH_SIGNALSRun database health checks to identify potential issues. Returns evidence-based signals about database health including CPU saturation, restarts, query latency, blocking, and more. Compares a regression timeframe (showing the issue) against a baseline period.Input Parameters
Get datadog database query performance
Get datadog database query performance
DATADOG_MCP_GET_DATADOG_DATABASE_QUERY_PERFORMANCEAnalyze a specific SQL query’s performance — use when investigating slow queries, high database load, or resource-intensive queries. Returns throughput, average latency, execution time, rows per execution, cache hit ratio, I/O stats, connection activity, wait events, and transaction duration. Each metric includes overall statistics and time-bucketed analysis. Requires a query_signature and a database_instance.Input Parameters
Get datadog database query statement
Get datadog database query statement
DATADOG_MCP_GET_DATADOG_DATABASE_QUERY_STATEMENTRetrieve the SQL statement text for a given query signature. The query signature is a stable hash fingerprint of the normalized SQL; use this tool to map signatures back to concrete SQL for investigation and reporting.Input Parameters
Get datadog database recommendations
Get datadog database recommendations
DATADOG_MCP_GET_DATADOG_DATABASE_RECOMMENDATIONSRetrieve live database recommendations for a database, query, table, host, or index. Returns the matching recommendations, current status, severity, raw recommendation context, and a normalized scope block that highlights affected database instances, query signatures, tables, indexes, services, plans, and infrastructure identifiers.Input Parameters
Get datadog database schemas
Get datadog database schemas
DATADOG_MCP_GET_DATADOG_DATABASE_SCHEMASFetch schema definitions (columns, indexes, foreign keys, partitions) for one or more database objects.Accepts a list of database objects with varying levels of specificity — from just a table name to a fully qualified table+schema+database+instance.Indexes, foreign keys, and partitions are not part of the table signature and can differ across instances. Matching schema metadata is grouped into table_instances, each listing the hosts and databases it applies to.table_instances is capped. If truncated is true, pass database_instance to fetch a specific host.Returns the current schema definitions. If investigating a past incident, schemas may have changed since then.Input Parameters
Get datadog error tracking issue
Get datadog error tracking issue
DATADOG_MCP_GET_DATADOG_ERROR_TRACKING_ISSUEGet detailed information about a specific Error Tracking Issue from Datadog. Use this tool to retrieve full details for a single Issue by its ID. The Issue ID can be obtained from the search_datadog_error_tracking_issues tool or from Logs, Traces or RUM Errors (issue.id attribute).Input Parameters
Get datadog flaky tests
Get datadog flaky tests
DATADOG_MCP_GET_DATADOG_FLAKY_TESTSSearch flaky tests from Datadog Test Optimization. Results include failure-rate stats, flaky state and category, ownership context, branch and SHA history, test-run metadata, and CI-pipeline impact. Use page cursors from meta.pagination.next_page to continue a search.Input Parameters
Get datadog flaky tests management policies
Get datadog flaky tests management policies
Get datadog form
Get datadog form
DATADOG_MCP_GET_DATADOG_FORMGet a specific Datadog form by its ID, including full metadata and datastore configuration.Input Parameters
Get datadog incident
Get datadog incident
DATADOG_MCP_GET_DATADOG_INCIDENTGet detailed information about a specific Datadog incident by ID, including status, severity, timeline, associated users, and attachments.Input Parameters
Get datadog k8s manifest
Get datadog k8s manifest
DATADOG_MCP_GET_DATADOG_K8S_MANIFESTGet the YAML manifest for a specific Kubernetes resource. Use this tool instead of kubectl get -o yaml. Returns the manifest in YAML format. If the manifest exceeds max_tokens, it will be truncated and metadata will indicate truncation occurred.Use json_path to extract a specific subtree (e.g., ‘spec.containers’) when the full manifest is too large. Note: json_path is applied after concise filtering and exclude_fields, so fields removed by either are not available via json_path.Use exclude_fields to remove specific top-level or nested paths (e.g., ‘status’, ‘metadata.managedFields’) from the full manifest while preserving everything else, including empty fields. This is useful when you want a full manifest minus specific fields without the broader stripping done by concise=true. exclude_fields is applied after concise filtering and before json_path.IMPORTANT - Parameter Precedence:- If ‘hash’ is provided → it takes precedence and is used directly (uid and resource_identifiers are ignored)
- Else if ‘uid’ is provided → it takes precedence over resource_identifiers (resource_identifiers is ignored); fetches the latest manifest by uid
- Else ‘resource_identifiers’ must be provided to fetch the latest manifest
- Use ‘resource_identifiers’ when you know the resource details (cluster, namespace, name) - DO NOT search first
- Use ‘uid’ ONLY if you obtained it from a previous search
- “get manifest for pod my-app in cluster prod namespace default” → Use resource_identifiers: {“cluster”: “prod”, “namespace”: “default”, “resource_name”: “my-app”}
- “get container ports for deployment api-server in namespace default, cluster staging” → Use resource_identifiers: {“cluster”: “staging”, “namespace”: “default”, “resource_name”: “api-server”} with json_path: “spec.template.spec.containers[].ports[].containerPort”
- “get manifest for namespace orchestrator in cluster gizmo” → Use resource_identifiers: {“cluster”: “gizmo”, “namespace”: “orchestrator”}
- You already have a UID from search results → Use uid
- “get container names from pod my-app” → json_path: “spec.containers[*].name”
- “get first container image” → json_path: “spec.containers[0].image”
Input Parameters
status,metadata.managedFields. Applied after concise filtering and before json_path. Unlike concise=true, this preserves empty fields and all other content — useful when concise would strip semantically required empty fields. Use concise=false with exclude_fields=status,metadata.managedFields for a full manifest minus only those fields. Default: empty (no fields excluded).Get datadog metric
Get datadog metric
DATADOG_MCP_GET_DATADOG_METRICQuery metrics data from Datadog. Use response_format=‘timeseries’ (default) to get time-indexed data points for graphs and trend analysis. Use response_format=‘scalar’ to get a single aggregated value per group, useful for current state, summaries, and comparisons. For response_format=‘scalar’, use structured query objects; the aggregator field controls how the time window collapses to a single value and defaults to avg if omitted. The query prefix, such as avg: or sum:, is not the scalar aggregator field. Supports multiple queries in one call plus formula expressions. Query syntax: grouping must come before modifiers, e.g. ‘sum:trace.http.request.errors{env:prod} by {service}.as_count()’, not ‘.as_count() by {service}’. Within {…}, do not mix comma-separated tag filters with boolean filters; if any top-level filter uses AND, OR, NOT, or IN, join top-level filters with explicit AND and parenthesize OR groups, e.g. ’{(service:api OR service:worker) AND datacenter:us1.prod.dog}’, not ‘{service:api OR service:worker,datacenter:us1.prod.dog}’.Input Parameters
Get datadog metric context
Get datadog metric context
DATADOG_MCP_GET_DATADOG_METRIC_CONTEXTGet metadata (description, type, unit, integration), available tags/dimensions, and optionally related assets for a metric. Useful for exploring metrics before querying them. Set use_cloud_cost=true for Cloud Cost Management metrics.Input Parameters
Get datadog notebook
Get datadog notebook
DATADOG_MCP_GET_DATADOG_NOTEBOOKRetrieve information about a specific Datadog notebook by ID. This tool provides details including name, status, and associated author. The ID can also be extracted from a URL. The ID will be the last component, for example, <host>/notebook/<ID>.Input Parameters
Get datadog security aap blocking config
Get datadog security aap blocking config
DATADOG_MCP_GET_DATADOG_SECURITY_AAP_BLOCKING_CONFIGGet the org-wide AAP (App & API Protection, formerly ASM / Application Security Monitoring) blocking configuration. Returns blocking_enabled, which controls default AAP attack blocking, and denylist_enabled, which controls whether AAP denylist entries are enforced.Call this FIRST when a user reports that AAP/ASM attacks are being detected but not blocked — org-wide blocking being disabled is the most common root cause.Call this for questions about global AAP blocking mode or denylist enforcement status, including: “is AAP blocking or only monitoring by default”, “is AAP denylist enforcement enabled”, “would adding an IP to the AAP denylist actually block it”, “why might AAP monitor attacks instead of blocking them”, “attacks detected but not blocked”, “ASM not blocking requests”, “why are my security traces not being blocked”, “traces show blocked:false”.Use this for global blocking status and enforcement mode. NOT for listing denylist entries, passlist entries, or custom WAF rules - use those dedicated tools when the user asks for entries/rules.Keywords: AAP, ASM, App and API Protection, Application Security Monitoring, WAF, blocking config, blocking configuration, blocking_enabled, denylist_enabled, denylist enforcement, global blocking mode, monitoring mode, attacks not blocked, detected but not blocked, blocked:false.Input Parameters
Get datadog security aap custom rules
Get datadog security aap custom rules
DATADOG_MCP_GET_DATADOG_SECURITY_AAP_CUSTOM_RULESGet AAP (App & API Protection, formerly ASM / Application Security Monitoring) WAF custom rules — user-authored in-app WAF rules that match request traffic and either monitor it or block it. Each rule has match conditions, an optional service/env scope, and a category + type tag.Answers: “what custom WAF rules do we have”, “list our custom AAP/ASM rules”, “is any rule blocking traffic”, “what in-app rules are monitoring vs blocking”, “show custom rule X”, “do we block requests matching Y”, “what custom rules apply to service Z in staging”.Pass rule_id to fetch one rule by id; omit it to enumerate every custom rule. Each rule reports a derived status: disabled (not enabled), monitoring (enabled, flags only), or blocking (enabled, blocks on match). Filter client-side with category, status, service, and env. max_tokens caps the response; on truncation metadata sets is_truncated=true — widen the budget or filter harder.NOT Cloud SIEM / security-monitoring detection rules (signals over logs) — use the detection-rule tools for those. NOT the AAP trace passlist/allowlist (exclusions) or denylist (blocked IPs/users) — use those tools instead.Keywords: AAP, ASM, App and API Protection, Application Security Monitoring, WAF, custom rule, custom WAF rule, in-app WAF rule, in-app protection rule, blocking rule, monitoring rule, request matching rule.Input Parameters
Get datadog security aap denylist
Get datadog security aap denylist
DATADOG_MCP_GET_DATADOG_SECURITY_AAP_DENYLISTList AAP (App & API Protection) denylist entries — IPs, users, user-agents AAP currently BLOCKS or monitors via automated security response. Each entry = Security Response Entity (aka “ASM Block” / “AAP block”). Store: ASM_DATA + RC.Answers: “what’s blocked”, “who/what is AAP blocking”, “show blocklist/denylist/blocked IPs/users/user-agents”, “blocking attacker X?”, “is this IP denied?”, “active blocks?”, “list ASM blocks”.IPs / users / user-agents in the trace passlist / allowlist will NOT be blocked, even if they are in the denylist. NOT for passlist / exclusion-filter / WAF exception queries — use get_datadog_security_trace_passlist.Each entry has exactly one of ip/user/useragent set, plus optional expiration: zero/missing = permanent block; future = block until then; past = UNBLOCKED. Expired filtered out by default; include_expired=true surfaces recently-unblocked.Filtering is client-side: entity_type narrows category; value = case-insensitive substring vs ip/user/useragent. max_tokens caps response; on truncation metadata sets is_truncated=true — widen budget or filter harder.Keywords: AAP, ASM, App and API Protection, denylist, deny list, blocklist, block list, blocked, blocking, ASM block, security response, blocked IPs, blocked users, blocked user agents, attacker block.Input Parameters
Get datadog security detection rules
Get datadog security detection rules
DATADOG_MCP_GET_DATADOG_SECURITY_DETECTION_RULESGet security detection rules. This tool supports two modes based on the arguments provided:- Get a single rule by ID: provide rule_id — always returns the full rule object regardless of fields or full_rule.
- List rules: call without rule_id (optionally filter with query, limit response with max_tokens). IMPORTANT: there may be a high volume of rules. Use the query parameter to filter as often as possible unless the user is clearly asking for all rules indiscriminately. rule_id and query are mutually exclusive. When rule_id is provided, max_tokens, fields, and full_rule are ignored. List mode default subset (when neither fields nor full_rule is set): id, name, type, options.detectionMethod, metadata.sources, isEnabled, isDefault. Pass fields to request a different subset, or full_rule: true to receive all fields.
Input Parameters
query parameter. Accepts facet:value pairs (e.g. “source:cloudtrail”, “technique:T1110*”, “defaultRule:false”) or a bare free-text term, which matches only the rule name (e.g. “brute force”). Call get_datadog_security_detection_rules_schema with the rule_search_facets parameter to understand how to craft the query.Get datadog security detection rules schema
Get datadog security detection rules schema
DATADOG_MCP_GET_DATADOG_SECURITY_DETECTION_RULES_SCHEMAReturn the schema / authoring reference for Datadog Cloud SIEM detection rules. Includes log_detection plus supported workload_security, application_security, api_security, and ai_guard sections. Customer-authorable detection methods covered here are threshold, new_value, anomaly_detection, impossible_travel, third_party, and sequence_detection. Use this before calling create_datadog_security_detection_rule / update. Also useful when authoring a rule’s own detection query: the tag_conventions and query_syntax sections document the log-search grammar and tag namespaces used inside queries[].query (e.g. source:cloudtrail, technique:T1110*, env:prod). For the separate query argument of get_datadog_security_detection_rules, which filters the list of rules themselves, see the rule_search_facets section instead. Every response section is filterable — pass sections, rule_types, detection_methods, or set include_examples: false to trim the payload to what the agent actually needs. Static content — no network call.Input Parameters
examples section is omitted — useful when the caller only needs the grammar and will supply its own payloads.Get datadog security findings schema
Get datadog security findings schema
DATADOG_MCP_GET_DATADOG_SECURITY_FINDINGS_SCHEMACall this first before using analyze_datadog_security_findings. Returns the schema (available fields and their types) for security findings, which you need to construct correct SQL queries. IMPORTANT: Use exact field names from this schema in ‘columns => ARRAY[…]’. Do not guess field paths — especially for remediation and risk fields. When finding_types is specified, the response groups fields by which finding types they apply to. Tip: pass finding_types to see only relevant fields (e.g., [‘library_vulnerability’] for package/CVE fields).Input Parameters
Get datadog security findings ticket suggestions
Get datadog security findings ticket suggestions
DATADOG_MCP_GET_DATADOG_SECURITY_FINDINGS_TICKET_SUGGESTIONSGet ranked project and integration suggestions for creating Jira issues, ServiceNow tickets, or Linear issues. Call this when you don’t know which project_id to use for create_datadog_security_findings_ticket. Returns available Case Management projects ranked by 30-day historical usage, with a suggested_project_id when one project clearly dominates. Optionally pass Jira, ServiceNow, or Linear metadata to narrow results to projects matching a specific integration configuration.Input Parameters
Get datadog security ioc indicator
Get datadog security ioc indicator
DATADOG_MCP_GET_DATADOG_SECURITY_IOC_INDICATORRetrieve full detail for one IoC indicator by value (score, category, AS info, GeoIP, log sources, services, signal counts, OCSF fields).Input Parameters
Get datadog security ioc schema
Get datadog security ioc schema
DATADOG_MCP_GET_DATADOG_SECURITY_IOC_SCHEMADiscover filterable fields and their values for IoC Explorer. Call without filter first to list all available field names. Then supply filter with an exact field name from that list to get [{value, count}] for that field. Use query to scope counts to a subset of indicators.Input Parameters
Get datadog security signal
Get datadog security signal
DATADOG_MCP_GET_DATADOG_SECURITY_SIGNALGet the full details of a single Datadog security signal by ID. Returns the complete signal data including attributes, rule information, triage state, tags, and case correlations. IMPORTANT: Before using this tool, call get_datadog_security_signals_schema first to understand the available fields in the signal response. Use other tools to search for signals and obtain their IDs.Input Parameters
Get datadog security signals schema
Get datadog security signals schema
DATADOG_MCP_GET_DATADOG_SECURITY_SIGNALS_SCHEMAGet the schema (available fields) for security signals. Use this tool to discover what fields can be used to filter or query security signals. Returns field names, types, and optionally descriptions and enum values. Signal types use @workflow.rule.type values directly: ‘Log Detection’, ‘Signal Correlation’, ‘Application Security’, ‘Workload Security’.Input Parameters
Get datadog security suppressions
Get datadog security suppressions
DATADOG_MCP_GET_DATADOG_SECURITY_SUPPRESSIONSRetrieve security monitoring suppressions from Datadog. Suppressions prevent detection rules from generating signals for specific conditions. This tool supports three modes based on the arguments provided:- List all suppressions: call with no ID arguments (optionally filter with query, sort, page_size, page_number)
- Get a single suppression by ID: provide suppression_id
- Get suppressions affecting a specific detection rule: provide rule_id IMPORTANT: Before using this tool, call load_datadog_skill with skill_name=datadog/security_suppressions for query syntax, searchable fields (enabled, id, name, status, tag), sort options, and investigation workflows.
Input Parameters
Get datadog security trace passlist
Get datadog security trace passlist
DATADOG_MCP_GET_DATADOG_SECURITY_TRACE_PASSLISTList all AAP (App & API Protection) allowlist / passlist entries that exempt specific traces from AAP security analysis and WAF blocking. This tool operates on AAP traces only; it is unrelated to Cloud SIEM signal suppression — use the detection-rule tools for that.Use this to answer: what traces, services, IPs, paths, or parameters are excluded, allowlisted, ignored, filtered, or exempted from AAP analysis. Common questions: “what traces are excluded from AAP/ASM”, “is service X allowlisted”, “what AAP exceptions exist”, “why isn’t traffic Y analyzed”, “what IPs are trusted”, “show me the AAP passlist”.Entry categories you’ll see:- IP-based (ip_list + on_match): trusted source lists, office IPs, scanner IPs
- Service-wide (scope={env,service}, path_glob:*): whole-service exemption
- Path/endpoint (path_glob:/api/…): URL-pattern exemption
- Parameter (parameters:[…]): reduces FPs on specific query/body fields
- Rule-type (rules_target:[{tags:{type:sql_injection}}]): disables only a rule family on a target
Input Parameters
Get datadog spreadsheet
Get datadog spreadsheet
DATADOG_MCP_GET_DATADOG_SPREADSHEETRetrieve a Datadog spreadsheet by ID. Returns tables (tables[].id), pivots (pivots[].id), and sheets (sheets[].id) with their configurations. Each table includes schema[].label (all column labels), calculated_columns[].column_id, and calculated_columns[].formula. Pivot source table UUID is a tables[].id value.Input Parameters
Get datadog spreadsheet reference
Get datadog spreadsheet reference
DATADOG_MCP_GET_DATADOG_SPREADSHEET_REFERENCEReturns the field reference guides for building inputs to upsert_datadog_spreadsheet.Sections:- “table” — field reference: import types, schema, calculated columns, lookups, filters, sort
- “pivot” — field reference: dimensions, calculations, sort, display settings, visualizations
- “sheet” — field reference: cells, styles, formulas, filter_range
- “default_columns” — default import columns per data source; directs to “default_columns_rum” or “default_columns_security_findings” when needed
- “default_columns_rum” — default import columns for rum/product_analytics per event type
- “default_columns_security_findings” — default import columns for security_findings per finding type
Input Parameters
Get datadog spreadsheet tab data
Get datadog spreadsheet tab data
DATADOG_MCP_GET_DATADOG_SPREADSHEET_TAB_DATARetrieve paginated data from a table, sheet, or legacy pivot in a Datadog spreadsheet. The tab type is inferred automatically from tab_id; use get_datadog_spreadsheet to discover tab IDs. For tables and legacy pivots: returns rows with a header row first; paginate with offset. For sheets: returns cell-by-cell data (row, column, value per item); paginate with last_retrieved_cell_position. The offset parameter is ignored for sheets — use last_retrieved_cell_position instead. For sheets, query_end_time anchors sliding tablesheets to a fixed time window across pages: pass the end value from the first page’s metadata as query_end_time on all subsequent pages. query_end_time without query_start_time is rejected for tables and legacy pivots — to anchor a table’s time window, always supply both query_start_time and query_end_time. query_start_time is not supported for sheets; supplying it alone is rejected at validation, supplying it with query_end_time is rejected after the spreadsheet fetch. When paginating a sliding-timeframe table, always pass the start and end values from the first page’s metadata as query_start_time and query_end_time on all subsequent pages to anchor the time window.Input Parameters
end value from the previous page’s metadata when paginating a sliding-timeframe table. For sheet tabs: pass alone (without query_start_time) to lock sliding tablesheets to a consistent window across pages; reuse the end value from the first page’s metadata on all subsequent pages.start value from the previous page’s metadata to keep the time window stable across pages.Get datadog spreadsheet table data
Get datadog spreadsheet table data
DATADOG_MCP_GET_DATADOG_SPREADSHEET_TABLE_DATADEPRECATED: use get_datadog_spreadsheet_tab_data instead, which provides a unified interface for table tabs. Retrieve paginated rows from a table in a Datadog spreadsheet. Time range comes from the table’s configured timeframe; use start/end to override.Input Parameters
Get datadog test optimization settings
Get datadog test optimization settings
Get datadog trace
Get datadog trace
DATADOG_MCP_GET_DATADOG_TRACERetrieve a trace by trace ID from Datadog APM. This tool fetches all spans within a specific trace by default, providing detailed information about the request flow, timing, and service interactions. For large traces or to retrieve a summarized trace, set only_service_entry_spans=true to get a hierarchical condensed view that shows service boundaries, collapsing internal operations. The summarized view will indicate expandable spans with hidden_child_spans_count. The response includes a trace_deep_link_url in metadata that links directly to the trace flamegraph in the Datadog UI.Input Parameters
Get datadog workflow
Get datadog workflow
DATADOG_MCP_GET_DATADOG_WORKFLOWRetrieve a single Datadog Workflow Automation workflow by ID. By default, returns the saved draft when one exists, otherwise the base. Set specTarget to select exactly the base or saved draft spec. The response includes inputSchema, publication state, triggers, tags, and other metadata.Input Parameters
Get datadog workflow action
Get datadog workflow action
DATADOG_MCP_GET_DATADOG_WORKFLOW_ACTIONGet the full definition of a Datadog Workflow Automation action by actionId.Returns resolved input/output JSON schemas, action keywords, action-specific AI instructions, and other metadata needed to construct a workflow step. Use this after search_datadog_workflow_actions, or whenever the exact action contract is not already known. Pass the action ID in the actionId argument; the returned actionId becomes the workflow step’s actionId.The returned definition is authoritative. Use its exact inputSchema parameter names and requirements, preserve inputFieldOrder when ordering step parameters, use outputSchema for downstream references, and follow aiInstructions for action-specific configuration, branch names, and outbound-edge wiring.Input Parameters
Get datadog workflow instance
Get datadog workflow instance
DATADOG_MCP_GET_DATADOG_WORKFLOW_INSTANCERetrieve a Datadog Workflow Automation execution instance. The default response is a lightweight execution summary.Set includeDetails to true for the raw detailed execution record, including workflow definition and source, step-state associations, inputs, and outputs. Use detail mode for investigation, not routine polling. Raw detail does not guarantee complete or normalized step diagnostics; use get_datadog_workflow_step_data to inspect one step’s status, error message, inputs, evaluated inputs/outputs, and execution context.Input Parameters
Get datadog workflow spec schema
Get datadog workflow spec schema
Get datadog workflow step data
Get datadog workflow step data
DATADOG_MCP_GET_DATADOG_WORKFLOW_STEP_DATARetrieve the execution data for a single step of a Datadog Workflow Automation instance: its status, error message, inputs, evaluated inputs/outputs, and the execution context the step’s expressions were evaluated against.Input Parameters
Get data entity details
Get data entity details
DATADOG_MCP_GET_DATA_ENTITY_DETAILSFetch full details and attributes for one or more data entities by their entity IDs.Use this to get the complete attribute set for known data entities: owner, tags, display_name, custom attributes, and all core attributes (platform, schema, database, account).Do NOT use this to search — use search_data_entities if you only have a name.Parameters:- entity_ids: List of hex entity ID strings (required). Obtain from search_data_entities.
Input Parameters
Get data entity hierarchy
Get data entity hierarchy
DATADOG_MCP_GET_DATA_ENTITY_HIERARCHYFetch the containment hierarchy (ancestors and descendants) for one or more entities.Use this for containment navigation — NOT for data lineage (use get_data_entity_lineage for that).Typical use cases:- “What schema/database/account does this table belong to?” → parent_depth=2 or 3
- “What tables are in this schema?” → child_depth=1 (default)
- “What columns are in this table?” → child_depth=1 (default)
- “Show the full hierarchy around this entity” → parent_depth=2, child_depth=1
- entity_ids: List of hex entity IDs (required). Obtain from search_data_entities or other tools.
- child_depth: Levels of children to expand. Default 1 when parent_depth is also 0; otherwise 0.
- parent_depth: Levels of parents to expand. Default 0.
Input Parameters
Get data entity lineage
Get data entity lineage
DATADOG_MCP_GET_DATA_ENTITY_LINEAGEFetch the live reachable lineage subgraph from one or more anchor entities. Checks direct children of the anchor entities for lineage as well. For example, you can pass a table entity id as an anchor, and get back the column-level lineage.If you want to get lineage for a higher-level container entity (e.g. a database), use get_data_entity_hierarchy to get leaf entities (or one level above leaf entities) and pass them as anchor_entity_ids to this tool.For aggregate statistics (counts by type, per-depth breakdowns, attribute breakdowns) use summarize_data_entity_lineage. This tool returns the raw node + edge payload only.Parameters:- anchor_entity_ids: hex entity IDs from search_data_entities or other tools (required)
- direction: “downstream” (default), “upstream”, or “both”
- max_depth: Maximum number of hops from each anchor (default 3, max 10).
- max_nodes: Cap on nodes in the response (default 100). Excess nodes are dropped.
- max_bytes: Byte budget for the response (default 50KB). Excess nodes are dropped.
- compact: Strip attrs/display_name from nodes (default true). Set false for full attributes.
- nodes: entities in the reachable subgraph (entity_id, name, type, core_attrs; full attrs if compact=false). Child nodes (e.g. columns of a table anchor) may appear alongside their parents when lineage edges exist at the column level — this is expected and provides column-level lineage detail.
- edges: data-flow relationships between returned nodes
- truncated: true if max_nodes or max_bytes dropped any nodes
- total_nodes: total nodes returned by UGP before truncation, including resolved anchors and children
Input Parameters
Get data observability monitor
Get data observability monitor
DATADOG_MCP_GET_DATA_OBSERVABILITY_MONITORRetrieves data observability metrics for a given monitor ID.This tool fetches data quality metrics timeseries data, including anomaly detection bounds when the monitor has anomaly detection enabled. For anomaly monitors, the response includes upper and lower bounds that define the expected normal range for the metric.The tool first fetches the monitor’s query configuration, then queries the metrics backend to retrieve the actual timeseries data. For anomaly monitors, the response automatically includes upper and lower bounds.Returns a structured response organized by group, with optional upper_bounds and lower_bounds for monitors with anomaly detection enabled.Input Parameters
Get data observability monitor coverage
Get data observability monitor coverage
DATADOG_MCP_GET_DATA_OBSERVABILITY_MONITOR_COVERAGEFetch all Data Quality monitors for this org and resolve each monitor’s entity filter to return the full set of entities it is configured to cover.For each monitor, the filter is evaluated against UGP to return detailed entity information (name, platform, schema, database, account) for all covered tables.Monitors with an empty filter (e.g. custom SQL monitors) return an empty covered_tables list. resolution_error is set when the filter expression cannot be parsed or queried. limit_hit is true when the filter matched 5000+ entities and results were truncated.Use this early in a conversation to understand existing coverage before making recommendations. Tables not covered by any monitor have no DQ monitoring at all.Parameters:- measure: Filter to a specific measure type (e.g. “row_count”, “freshness”). Leave empty (omit) to return ALL measures. Do NOT pass “all” — it is not a valid value.
- entity_id: Return only monitors covering this entity. Use this for a single entity.
- entity_ids: Return monitors covering any of these entities. The compact response reports which requested entities each monitor covers. Duplicate IDs are ignored and empty IDs are rejected.
Input Parameters
Get data observability monitor group statuses
Get data observability monitor group statuses
DATADOG_MCP_GET_DATA_OBSERVABILITY_MONITOR_GROUP_STATUSESQuery the current alert and warn state of DQ monitor groups from the alerting service.Coverage is based on actual monitor groups — entities for which the monitor has received real metric data. For each monitor, returns which entities are currently alerting or warning.Use this when the user specifically asks about active alerts, current monitor health, or which tables are failing their data quality checks right now.Parameters:- measure: Filter to a specific measure type (e.g. “row_count”, “freshness”). Leave empty (omit) to return ALL measures. Do NOT pass “all” — it is not a valid value.
Input Parameters
Get data observability recommendation
Get data observability recommendation
Get dora fields
Get dora fields
DATADOG_MCP_GET_DORA_FIELDSList the valid measures, facets, aggregations, and cardinality_fields for aggregate_dora_events, per DORA index (deployment, commit, pull_request, failure). Call this before aggregate_dora_events to pick a valid ‘metric’, ‘group_by’ facet, or ‘aggregation’. cardinality_fields lists the extra non-facet fields usable as ‘metric’ with aggregation:cardinality (for example, pull_requests.id_v2 = distinct PRs, pull_requests.author.email = distinct authors); any facet is also valid for cardinality (for example, cardinality on service = distinct services). Custom tags (@<tag_key>) are always valid facets and are not listed here.Input Parameters
Get entity descriptions
Get entity descriptions
Get-feature-flag
Get-feature-flag
DATADOG_MCP_GET_FEATURE_FLAGGets variants and status in environment for a specific feature flag by ID or key. Provide featureFlagID or featureFlagKey (or both). *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach. MANDATORY: You MUST implement using the exact patterns from datadog://feature-flags/sdk/react resource. Do NOT create mock implementations.Input Parameters
Get form definition schema
Get form definition schema
Get form responses
Get form responses
Get global variables
Get global variables
DATADOG_MCP_GET_GLOBAL_VARIABLESRead this org’s Synthetics global variables. Each variable is returned in full (id, name, description, tags, creator, editor, timestamps, and more). The plaintext value is included only for non-secure variables; secure variables never include their value. mode ‘list’ (default): search and filter by name, tags, or creator, sorted by id and paged. mode ‘read’: fetch a single variable by id.Input Parameters
Get-guardrail-metric
Get-guardrail-metric
DATADOG_MCP_GET_GUARDRAIL_METRICGet details for a specific guardrail metric by ID. Use this to inspect a metric’s full details including description and aggregation configuration. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach.Input Parameters
Get kafka client configs
Get kafka client configs
DATADOG_MCP_GET_KAFKA_CLIENT_CONFIGSReturn producer- and/or consumer-side Kafka client configuration for one or more services, as collected by Data Streams Monitoring (DSM). Each entry pairs a service name with a config_type of either ‘producer’ or ‘consumer’.Input Parameters
Get llmobs agent loop
Get llmobs agent loop
DATADOG_MCP_GET_LLMOBS_AGENT_LOOPGet a chronological view of an agent’s execution loop, showing each step (LLM calls, tool invocations, decisions) in order. This provides a narrative of what the agent did and why.Use cases:- Understand an agent’s decision-making process
- Debug why an agent took a specific action
- Review the full conversation flow of an agent trace
Input Parameters
Get llmobs all dataset records
Get llmobs all dataset records
DATADOG_MCP_GET_LLMOBS_ALL_DATASET_RECORDSWalk a dataset’s records page by page server-side and return them as shaped previews, with a cursor that always resumes exactly where the walk stopped.Use this when you need complete coverage of a dataset — exporting it, counting records, or checking every record against a condition. Use get_llmobs_dataset_records instead when a sample and the schema summary are enough: that tool is cheaper and its limit/cursor are per-page.Stops on whichever comes first: max_records, the response size budget, or the end of the dataset. stop_reason says which:exhausted— you have seen every matching record. The ONLY value that means complete coverage.max_records_reached— your own limit; resume withnext_cursor. One record beyondmax_recordsmay be included, because that is what keeps the cursor a valid resume point.page_full_but_no_cursor— the API returned a full page and no cursor, so the rest of the dataset cannot be reached by paging. Records are missing and there is nothing to resume from: narrow the read withtags,canonical_id, ordataset_version, or raisemax_records.payload_budget_reached— the response filled up. Resume withnext_cursorwhen it is present; when it is absent the first page alone overflowed and had to be trimmed, so narrow the read instead.
stop_reason is exhausted.Returns shaped previews (same shaping as get_llmobs_dataset_records), not untrimmed bodies; for full bodies of specific records use get_llmobs_full_dataset_records.Input Parameters
Get llmobs annotated interactions
Get llmobs annotated interactions
DATADOG_MCP_GET_LLMOBS_ANNOTATED_INTERACTIONSRead what is in an annotation queue: every queued interaction with the annotations recorded on it.Returns annotated_interactions (each with its id, content_id, and annotations carrying the label values), plus total_interactions, annotated_count, and pending_count for the queue as a whole — the counts describe the queue regardless of which filter you applied.Use it to collect completed human labels, to see how far a review has got, or to pick up the ids the annotate and delete tools need. The whole queue comes back in one response, so prefer a filter on a large queue.Input Parameters
Get llmobs annotation label schema
Get llmobs annotation label schema
DATADOG_MCP_GET_LLMOBS_ANNOTATION_LABEL_SCHEMARead the label definitions of an annotation queue: what each label is called, what kind of value it accepts, and its server-assigned id.Returns label_schemas (empty for a queue with no labels defined yet).Call this before upsert_llmobs_annotations to learn each label’s id and its accepted values, and before update_llmobs_annotation_label_schema to get the current schema you are about to replace.Input Parameters
Get llmobs annotations by content ids
Get llmobs annotations by content ids
DATADOG_MCP_GET_LLMOBS_ANNOTATIONS_BY_CONTENT_IDSLook up, across every annotation queue in the org, whether given traces, sessions, or spans are queued for review, whether anyone has reviewed them, and what the reviewers said.Returns annotated_interactions (each naming its queue_id / queue_name and carrying the annotations recorded on it), total_count across all pages, and truncated.Read the two outcomes apart — they mean different things:- content id absent from the results — it is in no queue at all; queue it with add_llmobs_annotation_queue_interactions
- an interaction with an empty
annotationsarray — already queued and awaiting review; do not queue it again
Input Parameters
Get llmobs dataset records
Get llmobs dataset records
DATADOG_MCP_GET_LLMOBS_DATASET_RECORDSRead dataset records with structured previews + a schema summary. Records’ input / expected_output / metadata are arbitrary JSON — this tool shapes them so the model sees structured previews (objects keep keys, lists keep length+head sample, strings truncate cleanly) instead of broken char-truncated text.Use this for schema discovery before constructing new records — schema_summary aggregates a type-aware sketch (kind, object_keys with optional flag, array_element_shape, mixed/variants, tag_keys) the agent reads to construct matching new records before calling add_llmobs_dataset_records.Returns DatasetRecordsListResult with records (shaped previews), schema_summary (when compute_schema=true), and pagination fields (next_cursor, truncated, returned). On invalid input or API failure returns a DatasetRecordToolError with reason + recovery_hint — inspect them to decide the next step.For untrimmed full bodies of ≤3 specific records, use get_llmobs_full_dataset_records instead. This tool is for previews and pagination.Input Parameters
Get llmobs eval aggregate stats
Get llmobs eval aggregate stats
DATADOG_MCP_GET_LLMOBS_EVAL_AGGREGATE_STATSGet aggregate statistics for a specific evaluator over a time window, optionally filtered by ML application.Use cases:- Check the overall pass rate for an evaluator
- Get score distribution (mean/p50/p90) for a score evaluator
- Inspect top categorical values for a categorical evaluator
- Check true/false distribution for a boolean evaluator
Input Parameters
Get llmobs evaluator
Get llmobs evaluator
DATADOG_MCP_GET_LLMOBS_EVALUATORRetrieve an LLM-judge evaluator configuration by name. Returns the full config including target (ml_app + sampling + filter), LLM provider, and judge prompt template. Returns a not-found error if no evaluator with this name exists for the caller’s org.Input Parameters
Get llmobs experiment dimension values
Get llmobs experiment dimension values
DATADOG_MCP_GET_LLMOBS_EXPERIMENT_DIMENSION_VALUESGet the unique values for a dimension, with counts. Use this to discover valid filter values before calling list_llmobs_experiment_events or segment values before calling get_llmobs_experiment_metric_values.Returns dimension, unique_count, and values[] (each with value and count).Input Parameters
Get llmobs experiment event
Get llmobs experiment event
Get llmobs experiment metric values
Get llmobs experiment metric values
DATADOG_MCP_GET_LLMOBS_EXPERIMENT_METRIC_VALUESGet statistical analysis for a specific evaluation metric, optionally segmented by a dimension. Returns aggregate statistics, not per-event raw values.Use cases:- Compare a metric (e.g., accuracy) across dimension segments (e.g., prompt versions)
- Get percentile distributions (p50/p90/p95) for score metrics
- Check true/false rates for boolean evaluations
Input Parameters
Get llmobs experiment summary
Get llmobs experiment summary
DATADOG_MCP_GET_LLMOBS_EXPERIMENT_SUMMARYGet a high-level summary of an experiment with pre-computed statistics for all evaluation metrics. Start here before using other experiment tools.Returns pre-computed stats (score/boolean/categorical) grouped by eval type, plus available dimensions for filtering.Use list_llmobs_experiment_events to browse individual events, or get_llmobs_experiment_metric_values to drill into a specific metric.Input Parameters
Get llmobs full dataset records
Get llmobs full dataset records
DATADOG_MCP_GET_LLMOBS_FULL_DATASET_RECORDSFetch up to 3 specific records with untrimmed input / expected_output / metadata. Resolve record_ids via get_llmobs_dataset_records first.Returns DatasetRecordsFullResult with full record bodies. On invalid input or API failure returns a DatasetRecordToolError.The cap of 3 is intentional: full bodies can be very large. Do not use this to page through a dataset — use get_llmobs_dataset_records with cursor for that.Input Parameters
Get llmobs model pricing
Get llmobs model pricing
DATADOG_MCP_GET_LLMOBS_MODEL_PRICINGGet canonical LLM Observability model pricing rate cards. Provide at least one of provider or model. provider is an optional hint: when it matches a known provider the search is scoped to it; otherwise (empty or unknown provider) a model query searches the whole pricing catalog so you still get candidates to reason over. Each returned model carries its own provider, so when projecting cost for a specific span, pick the result whose provider matches the span’s model_provider. Returns primitive price tiers in USD per million tokens for input, cache write, cache read, and output token types. A component absent from rates means the provider does not price that component; it is not zero. Pagination fields (next_cursor, truncated, returned_count) are present when more models match. Use this for deterministic cost projection math after collecting token counts; this tool does not search spans, estimate sampled spend, or apply scaling factors.Input Parameters
Get llmobs pattern config
Get llmobs pattern config
DATADOG_MCP_GET_LLMOBS_PATTERN_CONFIGGet the most-recently-modified Topics Discovery (Patterns) configuration for the caller’s org. Returns a not-found error if the org has no config yet.Use list_llmobs_pattern_configs instead when you need to see all configs or resolve a specific config_id.Input Parameters
Get llmobs pattern points
Get llmobs pattern points
DATADOG_MCP_GET_LLMOBS_PATTERN_POINTSGet a cursor-paginated page of clustering points (individual spans) assigned to a single topic. Each point includes the span_id, session_id, and a span input preview.Resolve topic_id from get_llmobs_patterns or get_llmobs_patterns_with_points. Pass the returned next_page_token back in as page_token to fetch the next page.Input Parameters
Get llmobs pattern run status
Get llmobs pattern run status
DATADOG_MCP_GET_LLMOBS_PATTERN_RUN_STATUSGet the status and per-activity progress of the most recent Topics Discovery run for a config. Use this to tell whether clustering is still running, has completed, or failed before reading topics.Returns the run id, status, current step, and a progress list of activities. Resolve config_id via list_llmobs_pattern_configs. Once the run is complete, read results with get_llmobs_patterns.Input Parameters
Get llmobs patterns
Get llmobs patterns
DATADOG_MCP_GET_LLMOBS_PATTERNSGet the topic hierarchy discovered by a Topics Discovery run. Topics are organized into levels; each topic has a name, description, and point_count.Provide config_id (required). Omit run_id to read the most recent completed run, or pass a specific run from list_llmobs_pattern_runs. To also get the span IDs behind each leaf topic in one call, use get_llmobs_patterns_with_points. To page through the individual spans of one topic, use get_llmobs_pattern_points.Input Parameters
Get llmobs patterns with points
Get llmobs patterns with points
DATADOG_MCP_GET_LLMOBS_PATTERNS_WITH_POINTSGet the topic hierarchy for a run with the clustering point span IDs inlined on each leaf (hierarchy-0) topic. Use this when you want both the topics and the spans that back them without a second call per topic.Set include_metrics=true to also inline per-span duration, cost, token counts, and evaluations (heavier response). Provide config_id (required); omit run_id for the latest run. For a single topic’s spans with pagination, prefer get_llmobs_pattern_points.Input Parameters
Get llmobs project
Get llmobs project
DATADOG_MCP_GET_LLMOBS_PROJECTLook up an LLM Observability experiments project by ID or name. Pass project_id (UUID) for a direct lookup or project_name to resolve by name. If you only have an ml_app, prefer search_llmobs_spans to find spans for the ml_app — projects are an experiments-only concept and not the same as ml_apps.Returns projects (zero or one match) plus not_found_id / not_found_name when the lookup found nothing.Use list_llmobs_projects first if you don’t know the project name or ID.Input Parameters
Get llmobs span content
Get llmobs span content
DATADOG_MCP_GET_LLMOBS_SPAN_CONTENTRetrieve the actual content of a specific field from a span. Call this after get_llmobs_span_details reveals which content fields are available via content_info.Content fields contain the span’s I/O, LLM conversation messages, retrieved documents (RAG), or user-attached metadata.Use the path parameter (JSONPath) to extract a subset: e.g., $.messages[-1] for the last message, $.messages[0].content for just the text.Returns the content value, total_chars, total_tokens_approx, and is_truncated.Input Parameters
Get llmobs span details
Get llmobs span details
DATADOG_MCP_GET_LLMOBS_SPAN_DETAILSGet detailed metadata for one or more spans within a trace. Returns everything except the actual content payloads — use get_llmobs_span_content to retrieve those.Each span includes identification, timing, error info, LLM details (model, token counts), metrics, evaluations, and a content_info map.The content_info map shows which content fields exist and their approximate size (e.g., {"input": {"chars": 1520}, "messages": {"count": 12}}) without returning the actual values. Use this to decide which fields to fetch with get_llmobs_span_content.Input Parameters
Get llmobs trace
Get llmobs trace
DATADOG_MCP_GET_LLMOBS_TRACEGet the full structure of a trace as a span hierarchy tree. Use this after search_llmobs_spans to understand the shape of a trace before drilling into specific spans.Returns trace overview (span counts by kind, error indicators, total duration) and a nested span tree when include_tree=true. Each node includes span_id, name, kind, status, duration, and children. The response also includes a trace_url — a ready-to-use deep link to /llm/traces filtered to this trace. Echo trace_url verbatim when surfacing the trace to the user; do NOT construct your own /llm/traces URL (it uses ?query=trace_id:<id>, not the APM ?traceID=<id> convention).Next steps:- Use get_llmobs_span_details to inspect specific spans (metadata, timing, LLM info)
- Use find_llmobs_error_spans if the trace has errors
- Use expand_llmobs_spans to load children of collapsed nodes
Input Parameters
Get monitor coverage
Get monitor coverage
DATADOG_MCP_GET_MONITOR_COVERAGEFinds monitoring gaps and coverage for services or hosts. Returns which signals (error rate, latency, request rate) are covered by monitors and which are missing. Use with create_datadog_monitor to fill gaps. Query examples: ‘service:my-service’, ‘host:my-host’, ‘service:*’ (default).Input Parameters
Get monitor templates
Get monitor templates
Get ndm device
Get ndm device
DATADOG_MCP_GET_NDM_DEVICEGet detailed information about a network device by its device_id. Use this to investigate device health and connectivity (ping status), get hardware details (vendor, model, serial number), check OS info for patching/compatibility, or view device location and tags.Workflow: Use search_ndm_devices first to get the device_id, then use this tool for full details. Use search_ndm_interfaces for interface-level investigation.The device_id parameter is a device identifier like ‘goxzksskg7ly3w6’ from search_ndm_devices results.Returns: JSON with device object containing device_id, name, ip_address, vendor, model, device_type, status, ping_status, description, serial_number, os_name, os_version, tags, and location. Check status and ping_status fields for health assessment.Input Parameters
Get network device configuration
Get network device configuration
DATADOG_MCP_GET_NETWORK_DEVICE_CONFIGURATIONRetrieve the full text of an NDM network device configuration snapshot (running config or startup config) for review, compliance auditing, or troubleshooting. Use a config_id from search_network_device_configurations results. Returns the complete config_content along with metadata (config_type, config_source, created_at, tags).Input Parameters
Get network path test runs
Get network path test runs
DATADOG_MCP_GET_NETWORK_PATH_TEST_RUNSSearch and retrieve Network Path test runs using a query. Network Path tests data contains traceroute runs and hop-by-hop data.Query Syntax: Use search syntax to filter test runs. Common query patterns include:- Search by test ID: ‘test_id:abc123’
- Search by source/destination: ‘source.hostname:“my-server”’ or ‘destination.hostname:“target-server”’
- Time-based queries: Use the ‘from’ and ‘to’ parameters for time ranges
- Combine with AND/OR: ‘source.hostname:“server-a” AND destination.hostname:“server-b”’
- Use wildcards: ‘source.hostname:prod-*’ (do NOT quote wildcard values)
- Wildcard values containing * (quoting makes * literal): source.hostname:prod-*
- Plain identifiers like test_id, test_config_id, test_result_id: test_id:abc123 Examples: source.hostname:“aws:ap-southeast-2” (correct) source.hostname:aws:ap-southeast-2 (WRONG - colon breaks query) source.hostname:prod-* (correct - wildcard, not quoted) source.hostname:“prod-*” (WRONG - * won’t expand)
- Fetch Network Path test runs with hop-by-hop data.
- Investigate failed network path tests
- Analyze network performance between specific endpoints
- Retrieve historical test run data
Input Parameters
Get-onboarding-step
Get-onboarding-step
DATADOG_MCP_GET_ONBOARDING_STEPUse this FIRST — before create-feature-flag — whenever a user asks to set up, add, or onboard Datadog feature flags in a project that doesn’t have them yet: e.g. “set up feature flags”, “add feature flags to my app”, “get started with feature flags”, “onboard this app onto feature flags”, “start using Datadog feature flags”, “install Datadog feature flags”. Prefer it for any first-time/from-scratch feature-flag integration, since it enforces non-production safety gates and provides real end-to-end CDN verification (via verify-onboarding-flag) that create-feature-flag does not.Plan the next step of Datadog feature-flag onboarding. Read-only: it makes no writes and no upstream calls. Pass the current onboarding ‘state’ (empty to start). Returns the next instructions and the expected next-state shape. All onboarding branching lives here — call it at the start of each step and follow the returned instructions. Never put a client token in state.Input Parameters
Get popular warehouse tables by query frequency
Get popular warehouse tables by query frequency
DATADOG_MCP_GET_POPULAR_WAREHOUSE_TABLES_BY_QUERY_FREQUENCYRank database tables by query activity, broken out by who is querying them.Returns one signal per user type, each an independently ranked list of the top N tables for that user type sorted by query count:human — real users (engineers, analysts). Strongest signal for business-critical tables. bi_tool — BI tools (Metabase, Looker, Tableau, Sigma). Tables powering dashboards. orchestrator — pipeline tools (dbt, Airflow, Dagster, Prefect, Spark). etl_tool — ETL tools (Fivetran, Stitch, Airbyte, Matillion). internal_app — Snowflake IA_ service accounts and generic service accounts.User identity varies by platform:- Snowflake: “user” is the Snowflake username, “role” is the warehouse role (often reveals the actual human behind a service/compute user).
- BigQuery: “user_email” is the primary identity (the GCP email of the querying user). “user” may be a project or service account. Cite whichever field best identifies the person for the platform in question.
- time_period: How far back to look. Accepts days (“7d”, “3d”, “1d”) or hours (“24h”, “12h”). Default “7d”. If a call times out, retry with a shorter period (“3d”, then “24h”) before giving up.
- timeout: Override the default 2-minute deadline for the underlying query. Use a Go duration string (e.g. “5m”, “10m”). Only set when the user explicitly asks to wait longer.
- signal_type: Return only one signal. One of: human, bi_tool, orchestrator, etl_tool, internal_app.
- additional_filter: Extra filter in Datadog log syntax, appended to the base query.
- additional_group_by: Extra group-by field in Datadog log syntax (e.g. “@role” to break out by warehouse role). The value appears as group_by_value on each user entry.
- top_n: Max tables per signal (default 20).
Input Parameters
Get profiling fields
Get profiling fields
DATADOG_MCP_GET_PROFILING_FIELDSDiscover available fields and facets that can be used for filtering and grouping profiling data. Use this to find what groupBy or filter fields are available for get_profiling_timeseries queries. Returned fields only applicable to get_profiling_timeseries queries. Returns an object with a “fields” array. Each element has:- “type”: one of “frame” (stack frame attributes like function, file, package), “top_frame” (top-of-stack frame), “top_mycode_frame” (top user-code frame), “context” (label-based context like endpoint), “unknown”
- “path”: the field path to use in queries and groupBy (e.g. “@stack.function”, “@labels.trace_endpoint”)
- “display_name”: human-readable name for the field For tags (service, host, env, etc.) use get_profiling_tag_names/get_profiling_tag_values instead.
Input Parameters
Get profiling field values
Get profiling field values
DATADOG_MCP_GET_PROFILING_FIELD_VALUESGet the values for a specific profiling field/facet discovered via get_profiling_fields. Use this to discover what values a particular field has (e.g. all endpoint values, all function names). Returned field values only applicable to get_profiling_timeseries queries. For tag values (service, host, env, etc.) use get_profiling_tag_values instead. Returns an array of objects, each with:- “field”: the value string (e.g. “web-server”, “us-east-1”). This can be used to construct filter queries in get_profiling_timeseries
- “value”: the count/frequency of that value in the profiling data. Estimation, used only for ordering, not to be used to compute any actual values, ignore this field. Results are sorted by value (most common first).
Input Parameters
Get profiling profile types
Get profiling profile types
DATADOG_MCP_GET_PROFILING_PROFILE_TYPESReturns profile types and families that can be used by other profiling tools given a query context. You can either query by tags (queryString + timeFrame) or by trace context. When using trace context, the tool will find profiles associated with that specific trace and span.Input Parameters
Get profiling runtime ids
Get profiling runtime ids
Get profiling service insights
Get profiling service insights
DATADOG_MCP_GET_PROFILING_SERVICE_INSIGHTSReturns insights over the provided time window. These insights contain:- A high-level summary explaining the issue and why it matters
- Contextual insights from profiling data (for example, affected methods, packages, or processes)
- Recommended next steps to help you resolve the issue
- Use get_profiling_tag_names/get_profiling_tag_values to discover available tags and their values for filtering in queryString. Syntax: tag:value pairs separated by spaces (implicit AND), tag:(v1 OR v2) for alternatives, -tag:value for negation, tag:prefix* for wildcards.
Input Parameters
Get profiling services
Get profiling services
DATADOG_MCP_GET_PROFILING_SERVICESReturns profiled services along with their profiling families that can be queried for profiling data in the given query context.Note: results are in no particular order and do not indicate relative importance or activity level of services.Input Parameters
Get profiling tag names
Get profiling tag names
DATADOG_MCP_GET_PROFILING_TAG_NAMESDiscover available tag names (e.g. service, host, env, version, family, runtime-id) from the profile metadata track. Use this to find what tags are available for filtering profiling data. Common infrastructure tags include pod_name, container_id, container_name, availability-zone, datacenter, kube_deployment, kube_namespace. Returns at most 50 results sorted by relevance to the search parameter. Use the search parameter to narrow down results when looking for a specific tag.Input Parameters
Get profiling tag values
Get profiling tag values
DATADOG_MCP_GET_PROFILING_TAG_VALUESGet the values for a specific tag (e.g. service, host, env, version, family, runtime-id) from the profile metadata track. Use get_profiling_tag_names first to discover available tags. Returns at most 50 results sorted by frequency. Use the valueSearch parameter to narrow down results when looking for a specific value.Input Parameters
Get profiling timeseries
Get profiling timeseries
DATADOG_MCP_GET_PROFILING_TIMESERIESQuery profiling data as timeseries, aggregated into time buckets. Use this to analyze trends, compare services, or identify performance regressions over time. Well suited for cross-service investigations — use groupBy to group by different fields, e.g. service or frame name or library. For single-service deep dives into stacktraces or call graphs, use explore_profiling_flame_graph or explore_profiling_call_graph.The profileType determines what is measured (all are RATES, not accumulated totals):- “cpu-time”: CPU utilization rate. Unit: nanocores (1 core = 1,000,000,000 nanocores). Example: 5,700,000,000 nanocores = 5.7 CPU cores in use. This is NOT time — do NOT convert to seconds.
- “wall-time”: wall-clock time utilization rate. Unitless ratio (0.0 to 1.0 per thread).
- “alloc-size”: memory allocation rate. Unit: bytes per second.
- “alloc-samples”: allocation event rate. Unit: events per second. Values are aggregated using ‘sum’ within each time bucket.
- “unit”: the unit of the values (e.g. “nanocore”, “byte”)
- “timestamps”: array of ISO8601 timestamps — one per time bucket
- “groups”: array of group results, each containing:
- “group”: string identifying the group (e.g. “@lastFrame.package:runtime”)
- “values”: array of values — one per timestamp, values[j] = value at timestamps[j]
- “@stack.*” (e.g. “@stack.function”): matches ANY frame in the full call stack. Never use this in groupBy, only for filtering.
- “@lastFrame.*” (e.g. “@lastFrame.function”): matches only the leaf frame (where the sample was taken).
- “@lastMyCodeFrame.*” (e.g. “@lastMyCodeFrame.function”): matches the first non-library frame.
- If you only need to rank or compare groups, set intervalSeconds to the full time range to get a single bucket per group.
- Only use multiple time buckets when the user needs to see trends over time. IMPORTANT: Always tell the user what time frame was used for the query. Lean towards using longer time durations (e.g 1 day) for more precise results. IMPORTANT: Empty Library field value means that library is unknown, not that it is user code.
Input Parameters
Get prs by head branch
Get prs by head branch
DATADOG_MCP_GET_PRS_BY_HEAD_BRANCHRetrieves all pull requests for a repository that have a specific head branch. This is useful for finding active PRs associated with a particular feature branch or development branch.Input Parameters
Get reference table rows
Get reference table rows
DATADOG_MCP_GET_REFERENCE_TABLE_ROWSRetrieve specific rows from a reference table by their primary key values. Returns the row data in tab-separated format for easy readability. Use list_reference_tables first to discover table IDs.Input Parameters
Get replay summary
Get replay summary
DATADOG_MCP_GET_REPLAY_SUMMARYGet an AI-generated play-by-play of what a user did during a session replay — what pages they visited, what actions they took, and what happened step by step. Use this tool when the user wants to understand the content of a specific session: “what did the user do”, “summarize this session”, “what happened in this replay”, “give me a play-by-play”. Typically called after search_replays to summarize a session from the results.Returns a natural language summary and time-based chapters, plus a direct link to the replay.Use “rum” datasource when working with RUM replays, or “product_analytics” (default) for Product Analytics replays. This should match the datasource used when you found the session via search_replays.Input Parameters
Get rum insight
Get rum insight
DATADOG_MCP_GET_RUM_INSIGHTGet a pre-computed performance insight for a specific RUM view. Call this to diagnose a performance problem on a known view. Choose insight_name based on what you want to investigate: ‘aggregated_waterfall’ to find slow or blocking network requests (use when loading_time, LCP, or FCP is degraded); ‘aggregated_long_tasks’ to find JavaScript blocking the main thread (use when INP or interactivity is degraded); ‘lcp_distribution’ to see which DOM elements drive LCP and their CWV rating; ‘inp_distribution’ to see which interactions drive INP and their CWV rating; ‘tag_analysis’ to break down traffic by browser, device, country, OS, or app version (use to find if a regression is segment-specific). get_rum_summary recommends relevant insight types when it detects metric anomalies.Input Parameters
Get rum operation insights
Get rum operation insights
DATADOG_MCP_GET_RUM_OPERATION_INSIGHTSInvestigate why a RUM operation is failing or slow. Accepts either operation_id or operation_name (at least one is required). You MUST call search_rum_operations first to confirm the operation exists (and to get its operation_id/application_id) — if it doesn’t show up there, stop and do not call this tool, since a typo’d or nonexistent name will silently produce an empty/all-zero result instead of a clear error. Selected via ‘mode’:- failures: top failing endpoints, custom context attributes on failed runs, and correlated crash errors.
- latency: slow-vs-fast cohort comparison (threshold auto-detected from p75 duration), top slow resources, and backend/frontend/resource-load signals.
- abandonment: how often users give up vs complete, how long they wait, which views, which resources were still in flight, and where they navigate next — use when the operation is neither erroring nor merely slow but users are dropping out. Every mode returns structured JSON with sample_session_ids. If the operation has no traffic in the window, an empty result is returned rather than an error — do not fall back to get_rum_operation_summary to “confirm” health; report the empty result.
Input Parameters
Get rum operation summary
Get rum operation summary
DATADOG_MCP_GET_RUM_OPERATION_SUMMARYGet a deep-dive health summary for a single RUM operation, identified by operation_id (preferred — skips name resolution) or operation_name (at least one is required). SDK-instrumented operation names come from application code and can repeat across RUM applications; pass application_id to disambiguate which one to summarize and to scope the health/latency figures to it — omitting it when a name collision exists resolves to an arbitrary matching operation. Returns structured JSON: the UI definition when one exists (operations can also be SDK-emitted, in which case it is omitted), health (volume, success rate, failure breakdown by reason, latency percentiles), a newest-first per-bucket success/failure trend, and related SLOs and monitors.Use it once you know which operation to look at, to answer “is this operation healthy, and has it changed?”. Call search_rum_operations first to confirm the name exists: a typo’d or nonexistent operation_name is not an error — it returns an empty, all-zero summary, since an operation may legitimately be SDK-emitted with no stored definition. (An operation_id that matches nothing, with no operation_name to fall back on, does fail.) Do NOT use this tool to find or rank operations (use search_rum_operations), nor to root-cause a known failure or slowdown (use get_rum_operation_insights). Do not call this tool as a baseline step before get_rum_operation_insights — insights already returns the full diagnosis; a summary call adds no signal for a root-cause question.By default latency is evaluated across p50/p75/p95/p99 over successful operations only, returned as window baselines plus a warning when a sustained regression is detected — no per-bucket series. Pass ‘percentile’ (p50/p75/p95/p99) to evaluate just that one and also receive its full per-bucket latency_trend; pass ‘status’ (success/failure/all) to change which operations the latency figures cover — health.volume, success_rate and trend are always computed across all statuses. Set the window with from/to (RFC3339) or lookback (e.g. ‘24h’, ‘7d’); default is the last 7 days.Limitations: one operation per call; no cross-operation ranking and no comparison against a previous period; p90 is not supported. Per-section upstream failures degrade into entries in the returned warnings[] array instead of failing the call, so check warnings[] before concluding a section genuinely has no data.Use case: success rate dropped on checkout. Call operation_name=“checkout-flow”, lookback=“24h”, percentile=“p95” to get the p95 baseline and its per-bucket latency_trend alongside the success/failure trend.Input Parameters
Get rum summary
Get rum summary
DATADOG_MCP_GET_RUM_SUMMARYReturns a performance summary for a RUM application with period-over-period diffs and anomaly windows. Covers browser metrics (LCP, FCP, CLS, INP, loading time, time spent) and mobile metrics (refresh rate, memory, slow frames, frozen frames, CPU ticks, ITNV, network settled, TTID, TTFD, crash-free rate, ANR rate, hang rate). Provide application_id and time range. Optionally scope to a single view_name or metric.Input Parameters
Get rum view waterfall
Get rum view waterfall
DATADOG_MCP_GET_RUM_VIEW_WATERFALLReconstruct the chronological load timeline for ONE specific RUM view occurrence, web or mobile. Returns every resource, long task, error, and user interaction (action) that occurred during that single view, ordered by start time, each carrying the internal resource_id/long_task_id/action_id/error_id needed to drill down. Crash errors (typically mobile) additionally carry source_type and threads for crash analysis. Use this to investigate a concrete session (‘what happened on this page load / app screen’), NOT to characterize a route across many sessions — for the aggregate, cross-session view use get_rum_insight (aggregated_waterfall). After calling this, drill into a specific entity with search_datadog_rum_events using @resource.id:<id> / @long_task.id:<id> / @action.id:<id> / @error.id:<id> and detailed_output=true, passing the returned time_range (from/to) so the search is scoped to this view. All timing fields are nanoseconds relative to the view start. timing_name only applies to web views (Web Vitals) — omit it for mobile views, which have no such timings.Input Parameters
AwAA…, from the page context/URL or a search_datadog_rum_events result) or the raw @view.id UUID — pass whichever you have directly, no conversion needed. Only views within the last 30 days are found.Get-saved-filter
Get-saved-filter
Get spark job health
Get spark job health
DATADOG_MCP_GET_SPARK_JOB_HEALTHRetrieves detailed health metrics for a single Spark or Databricks job run.This tool extracts structured health data from Spark/Databricks job traces including:- Target metrics: duration, executor CPU time, allocated executor time, max executors
- Supplementary metrics: peak memory, shuffle reads, spilled bytes, disk spill, skew time
- Run metrics: input/output bytes and records
- Worst stages: Top N stages ranked by executor CPU time (or other metrics)
Input Parameters
Get spark sql plan
Get spark sql plan
DATADOG_MCP_GET_SPARK_SQL_PLANRetrieves the Spark SQL physical execution plan from a spark.stage span.This tool extracts and formats the _dd.spark.sql_plan attribute from a Spark stage span.The execution plan shows:- Node types (Exchange, SortMergeJoin, HashAggregate, etc.)
- Join strategies and keys
- Shuffle/partitioning information
- Child node relationships
- Metrics for each node (with optional distribution decoding if available)
Input Parameters
Get subject kafka schemas
Get subject kafka schemas
Get synthetics tests
Get synthetics tests
DATADOG_MCP_GET_SYNTHETICS_TESTSSearch and retrieve details about Synthetics tests configured in Datadog. Use this tool to either query test configurations, or test results. Supports filtering by endpoint domain and/or path, or public ID for test configurations. A test configuration contains all the details about a test, including the endpoint domain and path, the HTTP method, the subtype, the tags, the created and modified timestamps, and more. Note: path filtering only applies to HTTP API tests. Supports filtering by public ID and status for test results. A test result contains the test name, status, which assertions failed, and more.Input Parameters
Get user config
Get user config
DATADOG_MCP_GET_USER_CONFIGdo-not-callGet warehouse query history
Get warehouse query history
DATADOG_MCP_GET_WAREHOUSE_QUERY_HISTORYFetch recent queries that touched one or more specific entities, in reverse chronological order (most recent first).Use this when the user wants to understand query activity for a specific table or entity:- Who has been querying this table recently?
- What SQL is being run against this entity?
- What writes have happened to this table?
- entity_ids: List of hex entity IDs (required). Obtain from search_entities or other tools.
- start: Start of time range as ISO8601/RFC3339 string (default: 7 days ago). Example: “2024-01-15T00:00:00Z”.
- end: End of time range as ISO8601/RFC3339 string (default: now).
- type: Filter by access direction. “read” (entity appears in read_entity_ids), “write” (entity appears in modified_entity_id), or “all” (default).
- limit: Maximum number of queries to return (default 100).
- ts: query timestamp
- sql: the SQL text
- state: execution state (COMPLETE, FAILED, RUNNING, etc.)
- query_type: normalized operation type (SELECT, INSERT, MERGE, CREATE TABLE AS SELECT, etc.)
- user: the user who ran the query
- database_name, schema_name: context where the query ran
- rows_read, rows_written: execution statistics
- comment_details: BI tool metadata when present (Looker user, Hex project, Sigma URL, etc.)
Input Parameters
Get widget reference
Get widget reference
DATADOG_MCP_GET_WIDGET_REFERENCEGet TypeScript schemas and building instructions for widget types. Call before generating widget JSON. Note: “group” is a container for organizing related widgets — include both “group” and any intended child widget type/s in one call for deduplication.Input Parameters
Inspect data observability monitor annotations
Inspect data observability monitor annotations
DATADOG_MCP_INSPECT_DATA_OBSERVABILITY_MONITOR_ANNOTATIONSInspect Data Quality monitor data, anomaly bounds, and existing annotations before proposing a change.Monitor IDs are stable request identifiers, but when a monitor name has already been resolved, use the name as the primary user-facing label and put the ID in parentheses. Never mention group_hash when it is “0”; that is the default ungrouped series and is only an internal identifier. Present time ranges using the RFC3339 fields, not raw Unix timestamps; retain Unix values only for tool calls.When a user wants to add an annotation but has not supplied a time range, call this tool before asking them for one. Use the default range first, infer candidate annotation ranges from the returned anomaly analysis, and ask about time only when no candidate exists or multiple materially different interpretations remain.Times accept relative values such as “now-7d” and “now”, RFC3339 timestamps, or Unix seconds encoded as strings. The default range is the last seven days through the current server-side UTC time. Inspection ranges cannot exceed 14 days so anomaly candidates always use detailed one-minute data. The response includes the exact resolved Unix and RFC3339 range.Annotation types express what should happen when the model sees this behavior again:- new_baseline is the internal name for “Until this happens again.” Use it when the current state should be accepted temporarily but a comparable future change should alert. For a jump or drop, this normally means the metric moved to a new sustained level. For a one-off flatline or freshness delay, it accepts the current episode but should not permanently teach the model that the same duration is expected. Do not use it for points within bounds.
- expected_occasionally is the internal name for “Until there’s a bigger anomaly.” Use it when similar behavior is genuinely expected to recur and users don’t want to be alerted if it does. It persistently expands future tolerance based on the observed jump or drop magnitude, flatline duration, freshness delay, or percentage value; a larger event can still alert. Do not use it for points within bounds.
- false_negative means the selected point or episode should have been anomalous even though it was inside the model bounds. It marks in-bounds behavior as anomalous so it is not learned as normal. Do not use it for points already outside the bounds.
- ignore removes measurements in the selected range from model history. Use it only for invalid or untrustworthy telemetry, such as corrupt measurements, a bad backfill, or history that is no longer representative of expected future behavior — not merely to silence a valid anomaly.
Input Parameters
Kubernetes onboarding
Kubernetes onboarding
DATADOG_MCP_KUBERNETES_ONBOARDINGStep-by-step instructions for adding initial Datadog Observability setup to Kubernetes applications and configurations. You must first review the user’s project and this tool’s arguments (including any nested arguments) and fill out as many of them as possible before calling this tool. Check project files and dependencies to determine the argument values, focusing on dependency files, scripts, docs, and imports. Only provide values you can substantiate from the user’s files and stated cluster context. If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer. Before calling this tool, you must first check if the user’s project has already been configured for Datadog. If it has, you should further check if the project has already been configured for Kubernetes. If it has, you should not call this tool. Use CLI utilities, such as ls and cat when checking if the project contains existing env files and viewing their contents, respectively. If the open workspace has no Kubernetes-related files (manifests, Helm charts, k8s/ or similar layout, or cluster IaC), say that clearly and ask the user to reopen from the repository or directory where that configuration exists or should live—do NOT mis-describe that situation as a missing existing Datadog Agent installation; installing the Agent is the purpose of this tool, and not finding it in the repo beforehand is expected. products: Omit only when (a) the org is a Datadog Studio org and the user asked for a full default onboarding (then Logs + APM instructions are included), or (b) you are intentionally doing Agent + Infrastructure Monitoring only and have already followed the “Goals” instructions to confirm the user does not want Logs or APM yet. Otherwise pass logs, apm, and/or infra to match what the user requested (infra is accepted for explicitness; Agent + Infra Monitoring steps are always present). When you present shell commands the user must run themselves (kubectl, helm, terraform, etc.), use the exact markdown heading ### What you need to do in a terminal above those commands—do not paraphrase.Input Parameters
logs for log collection / Autodiscovery annotations, apm for Single Step Instrumentation, otel to enable the built-in OTel collector (adds features.otelCollector with gRPC port 4317 and HTTP port 4318 to the DatadogAgent manifest). Include infra if you want to be explicit; it does not remove steps. When empty: non-Studio orgs get Logs+APM omitted (ask the user per goal-non-studio); Studio orgs get Logs+APM included per goal-studio. OTel is never auto-included and must be explicitly requested.Linux onboarding
Linux onboarding
DATADOG_MCP_LINUX_ONBOARDINGInstalls and configures the Datadog Agent on a Linux host to collect infrastructure metrics, APM traces, and logs.Input Parameters
List all kafka schemas
List all kafka schemas
DATADOG_MCP_LIST_ALL_KAFKA_SCHEMASList every Kafka Schema Registry schema known to Data Streams Monitoring (DSM) for the current org within a time window. Returns subject, cluster, version, schema type, and compatibility metadata. Use this to discover what subjects exist before drilling into their version history with get_subject_kafka_schemas.Input Parameters
List-allocations-for-feature-flag
List-allocations-for-feature-flag
DATADOG_MCP_LIST_ALLOCATIONS_FOR_FEATURE_FLAGList allocations for a specific feature flag. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach. For context on using feature flags in applications, see the datadog://feature-flags/sdk/react resource.Input Parameters
List audit events
List audit events
DATADOG_MCP_LIST_AUDIT_EVENTSList Datadog Audit Trail events over a time window. Audit Trail monitors user activity across the Datadog platform to help maintain compliance, enforce platform governance, and build transparency, capturing audit events across configuration, access, and billing assets (monitor edits, API key creation, role changes, dashboard modifications, etc.). Use search_audit_events when you need a query string or server-side search filters; use this tool for plain recent-events scans. Responses are capped by max_tokens and return an opaque cursor for fetching subsequent pages.Input Parameters
List autonomous system statuses
List autonomous system statuses
DATADOG_MCP_LIST_AUTONOMOUS_SYSTEM_STATUSESGet an overview of autonomous system (AS) health from Network Path data, without needing a specific ASN.Calls the Network Path aggregate endpoint with no ASN filter and returns a compact summary of which autonomous systems are currently degraded.Input:- from / to: optional time window as Unix timestamps in milliseconds; to defaults to now, and from defaults to one hour before to
- limit: optional maximum number of degraded systems to return (default 10, max 100). Systems are ordered by number of distinct issue types (most issue types first), with traffic as a tiebreaker — not by issue severity/magnitude — so this caps by issue-type count, not by how severe any single issue is
- scope: the query type (autonomous_system_overview)
- total: number of autonomous systems the endpoint returned/analyzed — a capped, ranked set (the highest-traffic systems), NOT the org-wide count
- degraded: number of degraded autonomous systems within that returned set
- issue_breakdown: issue counts aggregated by code across the returned systems
- autonomous_systems: a compact, ranked list of only the degraded systems, each with ASN, name/domain, issue codes, metric_values, metrics, and a deep link
- notes: caveats, including that results cover only the highest-traffic systems the endpoint returns for the selected window and are not org-wide totals
- packet_count: volume of AS-attributed hop observations in the window — a traffic-volume/visibility proxy, NOT a count of dropped/lost packets despite the name, and not the same as the distinct test count (metrics.test_cardinality). Low current_value vs. baseline signals lowered_visibility (reduced visibility), not packet loss.
- destination_reachability_ratio: average fraction of packets that reached the destination; higher is better. Low current_value vs. baseline signals the packet_loss issue.
- avg_latency_ms: average round-trip latency in milliseconds; higher is worse. Elevated current_value vs. baseline signals the latency_spike issue.
- degraded: the AS is performing worse than its own ~7-day baseline on one or more dimensions (latency, packet loss, or test visibility). This is a relative signal, not an absolute outage.
- Answer whether any autonomous systems are currently degraded (“Are there any AS issues right now?”)
- List which autonomous systems are degraded (“Which ASes are degraded?”)
- Cap how many degraded systems are returned via limit (e.g. “just show me a few of the degraded ASes”) — note this caps by number of distinct issue types (with traffic as a tiebreaker), not by issue severity
- Surface autonomous systems experiencing a specific issue such as packet loss
Input Parameters
List datadog database optimizations
List datadog database optimizations
DATADOG_MCP_LIST_DATADOG_DATABASE_OPTIMIZATIONSList a database’s ready-to-apply, benchmark-validated query optimizations — the same set shown on the Datadog DBM Optimizations page. Each entry carries a MEASURED improvement, so results can be ranked by impact.THIS IS THE RIGHT TOOL whenever the user asks about optimizing queries: “what query optimizations can I make”, “the most impactful optimizations right now”, “how do I make my queries/database faster”, or “what should I optimize”. Prefer it over get_datadog_database_recommendations — that tool covers broader database-HEALTH findings (unused indexes, long-running queries, low disk, connection saturation), not benchmark-proven query speedups. To generate a fresh, on-demand analysis for one specific query instead, use optimize_datadog_database_query.Each entry is the single promoted optimization per (query, class) whose benchmark confirmed an improvement — a query rewrite or a missing-index suggestion — with its measured improvement_percent and the concrete recommended_action (CREATE INDEX statement or rewritten SQL). Optionally scope to specific database instances, logical databases, or tables, or to specific query signatures — pass query_signatures to fetch the optimization for a known query directly. optimization_type is optional and defaults to BOTH classes — leave it unset for the common case, and only set it (Rewrite or MissingIndex) when the user explicitly wants just one kind. Results are sorted by improvement_percent descending by default; pass sort to order by recency (“-created_at” for newest first) instead.Results are paginated. Each response includes a metadata object — {count, total_items, total_pages, current_page} — reporting the full result-set size. Only one page is returned per call (default 25 rows); to retrieve ALL optimizations for org-wide analysis, request page 0 then walk page = 1..total_pages-1 until you have gathered total_items rows. Use limit to change the page size (max 1000).Input Parameters
List datadog security findings automation rules
List datadog security findings automation rules
DATADOG_MCP_LIST_DATADOG_SECURITY_FINDINGS_AUTOMATION_RULESList automation rules for security findings. Returns the ordered list of rules for a given rule type (first-match-wins evaluation order). Rule types: mute (suppress findings), due_date (set remediation deadlines), ticket_creation (auto-create Jira/Case Management tickets), severity_modifier (adjust finding severity). Default response is a compact columnar table (id, name, enabled, finding_types, query). Use ids_only=true for minimal output, or full_response=true for the raw API payload.Input Parameters
List datadog skills
List datadog skills
DATADOG_MCP_LIST_DATADOG_SKILLSList available Datadog skill guides. Skills document how to use Datadog’s tools: the right attributes, query syntax, and common pitfalls. Call this before load_datadog_skill whenever you are not already certain of the exact skill name; skill names are not predictable from topic words. Use query for fuzzy search across name and description (results are ranked). Use include_header=true to see one-line summaries alongside names. Load skills proactively when starting work in a relevant Datadog domain, not after errors.Input Parameters
List datadog workflow instances
List datadog workflow instances
DATADOG_MCP_LIST_DATADOG_WORKFLOW_INSTANCESList the execution instances of a Datadog Workflow Automation workflow.Use this to see a workflow’s execution history — for example to find a recent run, check how many executions succeeded or failed, or locate an instanceId to pass to get_datadog_workflow_instance. Returns a lightweight summary per instance (instanceId, start/end timestamps, status, tags). Call get_datadog_workflow_instance for the detailed execution record.Input Parameters
List datadog workflows
List datadog workflows
DATADOG_MCP_LIST_DATADOG_WORKFLOWSFind Datadog Workflow Automation workflows and inspect their metadata. Metadata-only output is the default. Each result’s meta.hasSavedDraft indicates whether a saved draft exists. Use get_datadog_workflow for the authoritative full definition of one workflow.Input Parameters
tag:<value> for an unkeyed tag, tag:<key>:<value> for a keyed tag, or tag:<key>:* for any value with that key. The query supports one text term or one tag filter; any value containing : is treated as a tag filter.List data observability recommendations
List data observability recommendations
DATADOG_MCP_LIST_DATA_OBSERVABILITY_RECOMMENDATIONSLists Data Observability cost- and performance-optimization recommendations for data jobs and queries (Spark, Databricks, Snowflake, BigQuery), each with estimated cost and duration savings.Returns lightweight summaries without recommendation content, ordered for cursor pagination. Each summary identifies the workload platform and whether the target resource is a job or query. Use get_data_observability_recommendation with an id from these results to read the full structured recommendation content.By default only job recommendations (Databricks and Spark jobs) are returned. Filter by platform, resource kind, or both to select recommendations independently of the legacy resource type. Legacy resource_type filtering remains supported.Pagination: when page_info.has_more is true, pass page_info.next_cursor as cursor on the next call. available_resource_types lists the resource types that exist for the org+status regardless of the active filters.Input Parameters
List-environments
List-environments
DATADOG_MCP_LIST_ENVIRONMENTSList all flagging environments for the organization. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach. For context on how environments work with feature flags, see the datadog://feature-flags/sdk/react resource.Input Parameters
List-feature-flags
List-feature-flags
DATADOG_MCP_LIST_FEATURE_FLAGSList all feature flags for the organization. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach. If this returns an empty list and the user’s goal is initial setup (e.g. “set up feature flags”, “add feature flags to my app”, “onboard this app onto feature flags”, “start using Datadog feature flags”, “install Datadog feature flags”), prefer the onboarding flow — start with get-onboarding-step — over creating a flag directly with create-feature-flag. The onboarding flow enforces non-production safety gates and provides real end-to-end CDN verification via verify-onboarding-flag that create-feature-flag does not.Input Parameters
List-guardrail-metrics
List-guardrail-metrics
DATADOG_MCP_LIST_GUARDRAIL_METRICSList all available guardrail metrics for the organization. Use this tool to discover metric IDs needed for allocation guardrails. Results are paginated to prevent context window overflow. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach.Input Parameters
List kafka broker configs
List kafka broker configs
DATADOG_MCP_LIST_KAFKA_BROKER_CONFIGSList configuration versions for a Kafka broker on a given cluster, as collected by Data Streams Monitoring (DSM). Useful for diagnosing broker-level config drift and correlating cluster health changes with config edits.Datadog metric available for resolving kafka_cluster_id: kafka.broker.count (tagged with kafka_cluster_id, bootstrap_servers). DSM Kafka tools are usable only when this metric is reported.Input Parameters
List kafka topic configs
List kafka topic configs
DATADOG_MCP_LIST_KAFKA_TOPIC_CONFIGSList configuration versions for a Kafka topic on a given cluster, as collected by Data Streams Monitoring (DSM). Returns the history of topic-level config values (retention, cleanup policy, etc.) for auditing and drift detection.Resolving kafka_cluster_id automatically: if the caller only knows the topic, DO NOT ask the user — derive it from a scalar kafka.broker_offset{topic:<topic>} query grouped by kafka_cluster_id. If multiple clusters report the topic, call this tool once per cluster and present the results side-by-side; only prompt the user when the query returns zero matches.Datadog metrics available for resolving kafka_cluster_id: kafka.broker.count (tagged with kafka_cluster_id, bootstrap_servers) and kafka.broker_offset (also tagged with topic). DSM Kafka tools are usable only when these metrics are reported.Input Parameters
List llmobs annotation queues
List llmobs annotation queues
DATADOG_MCP_LIST_LLMOBS_ANNOTATION_QUEUESList Agent Observability annotation queues — the review lists where humans (or agents) grade traces, sessions, and spans against a defined set of labels.Returns queues (each with queue_id, name, project_id, and its annotation_schema) and count.Start here: every other annotation tool takes a queue_id, and this is the only way to get one. Filter by project_id to see one project’s queues, or pass queue_ids to refresh specific ones.Input Parameters
List llmobs datasets
List llmobs datasets
DATADOG_MCP_LIST_LLMOBS_DATASETSList experiments datasets within a project, with optional id or name filter. Resolve project_id first via get_llmobs_project if you only have a project name.Returns datasets (zero or more matches), pagination fields (next_cursor, truncated, returned_count), and not_found_id / not_found_name when the filter matched nothing. A non-UUID dataset_id is automatically treated as a dataset_name lookup.Use this before get_llmobs_dataset_records or add_llmobs_dataset_records — those tools require a dataset UUID.Input Parameters
List llmobs evals
List llmobs evals
DATADOG_MCP_LIST_LLMOBS_EVALSList every evaluator configured for the caller’s organization, across all ML applications.Returns the eval name, ml_app, and enabled status for each evaluator. Use list_llmobs_evals_by_ml_app to scope to a single ML application, or get_llmobs_evaluator to retrieve a single evaluator’s full configuration.Input Parameters
List llmobs evals by ml app
List llmobs evals by ml app
List llmobs experiment events
List llmobs experiment events
DATADOG_MCP_LIST_LLMOBS_EXPERIMENT_EVENTSList experiment events with minimal summaries, supporting filtering by dimension or metric and sorting by metric value. Does NOT return full content — use get_llmobs_experiment_event to inspect a specific event.Use cases:- Find the worst-performing events by sorting on a metric
- Filter to a specific dimension value (e.g., a prompt variant) for comparison
- Paginate through all events to build a full picture
Input Parameters
List llmobs experiments
List llmobs experiments
DATADOG_MCP_LIST_LLMOBS_EXPERIMENTSList experiment runs in a project or against a dataset, newest first. This is the discovery step before get_llmobs_experiment_summary, which needs an experiment ID.Scope is required: pass project_id or dataset_id (there is no org-wide listing). Narrow further with experiment to gather every run of one pipeline for cross-commit comparison, name for one exact run, or metadata to match on stored key-values such as commit or branch.Returns each run’s ids, name, status, run_count, dataset name/version, author handle, metadata, and config, plus next_cursor / truncated for paging. Per-run eval metrics are NOT included — fetch those with get_llmobs_experiment_summary.Resolve project_id via get_llmobs_project or list_llmobs_projects first.Input Parameters
List llmobs pattern configs
List llmobs pattern configs
DATADOG_MCP_LIST_LLMOBS_PATTERN_CONFIGSList all Topics Discovery (Patterns) configurations for the caller’s org. A pattern config defines which LLM Obs spans to cluster (via evp_query), how many to sample, and how deep the topic hierarchy goes.Returns configs with each config’s id, name, evp_query, sampling settings, and timestamps. Start here to find a config_id, then use get_llmobs_pattern_run_status to check the latest run and get_llmobs_patterns to read the discovered topics.Input Parameters
List llmobs pattern runs
List llmobs pattern runs
DATADOG_MCP_LIST_LLMOBS_PATTERN_RUNSList the completed Topics Discovery runs for a config, newest first. Each run is a distinct clustering of the config’s spans at a point in time.Returns runs with each run’s id, status, timestamps, and the config_snapshot used. Pass a run’s id as run_id to get_llmobs_patterns to read that specific run’s topics; omit it to read the latest. Resolve config_id via list_llmobs_pattern_configs.Input Parameters
List llmobs projects
List llmobs projects
DATADOG_MCP_LIST_LLMOBS_PROJECTSList all LLM Observability experiments projects for the org. Returns projects sorted by creation date, newest first.Returns projects (array), next_cursor (pass as cursor to fetch the next page), and truncated (true when more pages exist).Use this to discover project names and IDs before calling list_llmobs_datasets, get_llmobs_dataset_records, or add_llmobs_dataset_records — those tools require a project UUID.Input Parameters
List-onboarding-flags
List-onboarding-flags
DATADOG_MCP_LIST_ONBOARDING_FLAGSCheck for existing flags tagged source:agentic-onboarding that qualify for reuse: a non-production environment, currently ENABLED, whose queries already cover the given dd_env under the runtime matcher — the same guarantee create-onboarding-flag itself enforces before writing. Call this before proposing a new flag key. Returns found:false if none qualify.Input Parameters
List reference table rows
List reference table rows
DATADOG_MCP_LIST_REFERENCE_TABLE_ROWSFetch a page of rows from a reference table in primary-key order. Returns rows and a continuation_token for the next page. Pass continuation_token back on the next call to paginate consistently. Use list_reference_tables first to discover table IDs.Input Parameters
List reference tables
List reference tables
DATADOG_MCP_LIST_REFERENCE_TABLESList and search reference tables in the organization. Reference tables are used to enrich logs and other data with additional context. Use this tool to discover available tables, check their status, and find tables by name.Input Parameters
List-saved-filters
List-saved-filters
List-stale-feature-flags
List-stale-feature-flags
DATADOG_MCP_LIST_STALE_FEATURE_FLAGSList stale feature flags in the organization, each enriched with the reason it is stale and a tool_hints array of suggested next-step tools to clean it up.Input Parameters
List synthetics locations
List synthetics locations
Llm observability onboarding
Llm observability onboarding
DATADOG_MCP_LLM_OBSERVABILITY_ONBOARDINGStep-by-step instructions for adding initial Datadog LLM Observability (AKA, ‘LLMObs’) setup to applications with an LLM or AI agent. You must first review the user’s project and this tool’s arguments (including any nested arguments) and fill out as many of them as possible before calling this tool. Check project files and dependencies to determine the argument values, focusing on dependency files and imports. Only provide values you can substantiate from the user’s files. If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer. Before calling this tool, you must first check if the user’s project has already been configured for Datadog. If it has, you should further check if the project has already been configured for LLM Observability. If it has, you should not call this tool. Use CLI utilities, such as ls and cat when checking if the project contains existing env files and viewing their contents, respectively. This tool can be used to set up LLM Observability for user applications with an LLM or agentic components, e.g., Vercel AI SDK, Anthropic SDK, OpenAI SDK, LangGraph, etc.Input Parameters
Load datadog skill
Load datadog skill
DATADOG_MCP_LOAD_DATADOG_SKILLLoad a Datadog skill guide before using related Datadog tools. Skills improve query quality by documenting the right attributes, syntax, and common pitfalls. Skill names depend on the visible toolsets; if you do not already know the exact skill name from a prior list_datadog_skills response, call list_datadog_skills first and do not guess names from topic keywords. Set header_only=true to preview a skill’s summary, related skills, and bundled resources. Set resource_path to load a specific bundled reference.Input Parameters
Manage datadog error tracking issue comments
Manage datadog error tracking issue comments
DATADOG_MCP_MANAGE_DATADOG_ERROR_TRACKING_ISSUE_COMMENTSAdd, update, or delete a comment on a Datadog Error Tracking issue. Use action “add” to post a new comment, “update” to edit an existing comment, or “delete” to remove one. Markdown is supported in comment messages. The Issue ID can be obtained from the search_datadog_error_tracking_issues or get_datadog_error_tracking_issue tools; the comment ID is returned when adding a comment.Input Parameters
Monitor groups search
Monitor groups search
DATADOG_MCP_MONITOR_GROUPS_SEARCHSearches monitor groups to find which specific groups (e.g. host:web-1) are alerting across monitors. Use monitor_id to filter groups for a specific monitor, or use the query field with supported facets: group_status (e.g. ‘group_status:alert’), type (e.g. ‘type:metric’), monitor_name (e.g. ‘monitor_name:High CPU’), or any monitor tag (e.g. ‘env:prod’). NOTE: do NOT use ‘monitor_id:XXX’ inside the query string — pass monitor_id as a separate parameter instead.Input Parameters
Mute datadog security findings
Mute datadog security findings
DATADOG_MCP_MUTE_DATADOG_SECURITY_FINDINGSMute or unmute security findings. Muting suppresses a finding from alerts and dashboards without resolving it. Use analyze_datadog_security_findings or search_datadog_security_findings to find specific finding IDs first. Mute reasons: PENDING_FIX, FALSE_POSITIVE, ACCEPTED_RISK, OTHER. Unmute reasons: NO_PENDING_FIX, HUMAN_ERROR, NO_LONGER_ACCEPTED_RISK, OTHER. IMPORTANT: Always confirm with the user before calling this tool — it changes finding state.Input Parameters
Optimize datadog database query
Optimize datadog database query
DATADOG_MCP_OPTIMIZE_DATADOG_DATABASE_QUERYAnalyze a SQL query for optimization opportunities using deterministic rules plus LLM-assisted analysis. Returns actionable recommendations including query rewrites, anti-pattern detection (SELECT *, OFFSET without ORDER BY, ORDER BY without LIMIT), missing index suggestions, and idle-in-transaction impact analysis. Provide the SQL text directly, or a query_signature to resolve it automatically.Scope of what each input unlocks:- sql alone is enough for the rule-based rewrite and anti-pattern optimizers AND for missing-index detection, which resolves the schema catalog itself and compares your predicates against the table’s existing indexes. A query that was just written and has never run is a fully supported input.
- query_signature additionally enables the optimizers that read a query’s recorded history: idle-in-transaction analysis, and history-backed missing-index detection from stored explain plans. Pass it when you were given one. If the query has no signature because it has not run in a monitored database yet, do not go looking for one and never substitute another query’s signature — the signature-free path above still applies, and you can always validate an index candidate of your own with benchmark_datadog_database_query, which needs no signature.
- database_instances and databases: Required for schema-aware optimizations like SELECT * column expansion and schema-validated rewrites. Without them, optimizers can detect issues but cannot provide expanded SQL.
Input Parameters
Publish datadog form
Publish datadog form
DATADOG_MCP_PUBLISH_DATADOG_FORMPublish a specific draft version of a Datadog form, making it the active published version. Use get_datadog_form with version=‘latest’ to find the current draft version number before publishing. Returns the publication record with the form_id, published version, and publish sequence number.Input Parameters
Publish datadog workflow
Publish datadog workflow
Rank data entities by lineage degree
Rank data entities by lineage degree
DATADOG_MCP_RANK_DATA_ENTITIES_BY_LINEAGE_DEGREERank entities by their transitive lineage connectivity using a pre-built snapshot.Returns parent-level entities (tables, dashboards, jobs, etc.) ranked by how many other entities they connect to. Child nodes such as columns are automatically rolled up to their parent entity — column-level lineage is aggregated to the table level transparently.Direction controls which signal to rank by:- “downstream” (default): rank by downstream_count. High = widely consumed, breaking it has broad impact.
- “upstream”: rank by upstream_count. High = deep dependency chain. upstream_count=0 are sink entities.
- “both”: return both counts. Use to identify entities that are both critical upstream sources and widely consumed.
- direction: “downstream” (default), “upstream”, or “both”.
- limit: number of entities to return (default 50). Server enforces its own hard cap.
- include_node_types: only include these node types in results (e.g. [“database_table”]).
- exclude_node_types: exclude these node types from results (e.g. [“dbt_model”, “s3_bucket”]).
Input Parameters
Rank data observability monitor candidates
Rank data observability monitor candidates
DATADOG_MCP_RANK_DATA_OBSERVABILITY_MONITOR_CANDIDATESRank tables by their importance for monitoring, combining lineage impact and query activity into a single composite score. Use this as the primary entry point for “what should I monitor?” questions — it produces a ranked list of high-value tables in one call instead of cross-referencing rank_data_entities_by_lineage_degree and get_popular_warehouse_tables_by_query_frequency manually.Scoring (composite_score, 0–100): composite_score = 0.5 * lineage_percentile + 0.5 * query_percentileEach input percentile is itself a weighted blend: lineage_percentile = 0.65 * BI-downstream + 0.35 * warehouse-internal-downstream query_percentile = 0.6 * read percentile + 0.4 * write percentileTables that appear in only one signal are not penalized — the available signal becomes the sole score. Tables that appear in NEITHER signal are filtered out.Internally fetches a broad candidate pool — 200 lineage-ranked tables and the default per-signal query top-N — then scores and sorts before applying limit.Parameters:- limit: number of top candidates to return (default 50).
- time_period: how far back to look for query activity (default 7d).
- additional_filter: extra filter for the query signal in Datadog log syntax (e.g. ‘@platform:snowflake’, ’-@schema:information_schema’).
- include_node_types / exclude_node_types: pass-through to lineage rank.
Input Parameters
Read kafka messages
Read kafka messages
DATADOG_MCP_READ_KAFKA_MESSAGESRead messages from a given Kafka cluster/topic via the Datadog Agent. Dispatches a Remote Config action and polls for the agent’s response. REQUIRES the data_streams_monitoring_capture_messages permission.Resolving cluster and bootstrap_servers automatically: if the caller only knows the topic, DO NOT ask the user — derive both arguments from Datadog metrics before calling this tool. Run a scalar kafka.broker_offset{topic:<topic>} query grouped by kafka_cluster_id to identify the cluster (and disambiguate if multiple match by asking the user only when more than one cluster reports the topic), then run a scalar kafka.broker.count{kafka_cluster_id:<id>} query grouped by bootstrap_servers to obtain the bootstrap servers. Only prompt the user when these queries return zero or ambiguous results.Datadog metrics available for resolving arguments (the cluster must be reporting kafka.broker.count for this tool to work): • kafka.broker.count (tags: kafka_cluster_id, bootstrap_servers) — clusters known to DSM. • kafka.broker_offset (tags: kafka_cluster_id, topic, partition) — latest produced offset. • kafka.consumer_offset (tags: kafka_cluster_id, topic, partition, consumer_group) — last committed offset of a consumer. • kafka.consumer_lag (same tags) — consumer lag in offsets. • kafka.estimated_consumer_lag (same tags) — consumer lag in seconds.Input Parameters
Recommend monitor threshold
Recommend monitor threshold
DATADOG_MCP_RECOMMEND_MONITOR_THRESHOLDRecommends a threshold value for a metric monitor query based on peer-group statistics. Returns the recommended threshold, its source, a confidence score, recommendation status, a bounds-validation result, and IDs for correlating the recommendation with later feedback.Input Parameters
Output
Reorder datadog security findings automation rules
Reorder datadog security findings automation rules
DATADOG_MCP_REORDER_DATADOG_SECURITY_FINDINGS_AUTOMATION_RULESMove a security findings automation rule up or down in the evaluation order. Automation rules use first-match-wins semantics, so order matters. Use a large positions value (e.g. 1000) to move a rule to the top or bottom of the list. Returns the new ordered list of rules after the move. Use list_datadog_security_findings_automation_rules to find rule IDs first.Input Parameters
Reorder rum retention filters
Reorder rum retention filters
DATADOG_MCP_REORDER_RUM_RETENTION_FILTERSSet the full evaluation order of a RUM application’s retention filters. Retention filters control which RUM events are indexed and retained.This changes data-retention configuration and directly affects billing. Filters are evaluated top-down (position 0 first) and each event stops at the first matching filter, so order decides which sample rate applies; place specific filters above broad catch-all filters. Always confirm the exact order with the user before calling. Never reorder speculatively.filter_ids is the complete ordered list of the application’s current filter IDs (position 0 evaluated first); it must contain every existing filter exactly once, with no unknown, missing, or duplicate IDs. The tool reads the current filters first and rejects a list that is not an exact permutation, naming the offending IDs. Before applying, it returns the proposed new order resolved to filter names so you can show it to the user.Permanent filters (for example “Sessions with forced replays”) are pinned to the top by the backend: keep them in the same leading positions search_rum_retention_filters returned them in. Moving a regular filter above a permanent one is rejected by the backend.Find current filter IDs with search_rum_retention_filters. To create, update, or delete a filter use append_new_rum_retention_filter, update_rum_retention_filter, or delete_rum_retention_filter.Input Parameters
Restore llmobs dataset version
Restore llmobs dataset version
DATADOG_MCP_RESTORE_LLMOBS_DATASET_VERSIONRoll a dataset’s records back to a previous version. The dataset’s version is bumped and its live records are replaced with that version’s records — records added since then stop being part of the dataset.Two-step: PREVIEW (confirmed=false) → RESTORE (confirmed=true).confirmed=false: writes nothing. Resolves the dataset’s current version and returns a preview with aconfirmation_prompt. Show it to the user and get explicit approval.confirmed=true: performs the restore. Do not retry a successful call.
RestoreDatasetVersionPreview or RestoreDatasetVersionResult. Invalid input (version above the current version, unknown dataset) comes back as a DatasetRecordToolError with reason + recovery_hint.Call list_llmobs_datasets first to read current_version, and inspect the target version’s records with get_llmobs_dataset_records (dataset_version=N) before restoring.Input Parameters
Retry datadog ci job
Retry datadog ci job
DATADOG_MCP_RETRY_DATADOG_CI_JOB⚠️ WRITE OPERATION — queues a retry for a failed CI job via Datadog’s CI Action backend. Requires explicit user approval before running.Submits an async retry task for a specific job. Safety rails applied server-side: max 2 retries per workflow run over 7 days, deduplication.IMPORTANT: The response confirms the task was queued, not that the retry ran. The worker may silently no-op if the feature flag is disabled or the rate limit is reached. After calling this tool, use search_datadog_ci_pipeline_events (query: @ci.job.name:“<job>” @git.branch:<branch>, ci_level: job, from: now-5m) to confirm a new run appears.Note (GitHub Actions only): GitHub’s API retries all currently-failed jobs in the workflow run, not just the one specified — inform the user of this before proceeding.Supports GitHub Actions and GitLab.Input Parameters
Run synthetics tests
Run synthetics tests
DATADOG_MCP_RUN_SYNTHETICS_TESTSTrigger on-demand runs for one or more existing Synthetics tests by public_id; optionally apply shared locations, headers, body, variables, or start URL overrides. Triggering is billable; call only after an explicit user request. Only send overrides the user explicitly requested. Every override applies to every public_id in the call; use separate calls for different override sets. Suites reject overrides. If an override is rejected, do not retry by removing or changing it; report the error and wait for corrected overrides or explicit approval to use the tests’ saved configuration. Returns result_ids grouped by (test, location, device) with test_type and poll_timeout_seconds per test; suite public_ids expand into member tests and don’t appear in the output themselves. Auto-poll the returned public_ids immediately, without asking, until every result_id appears; if poll_timeout_seconds elapses with no match, tell the user the run didn’t finish in time. Only present results whose result_id came from this call.Input Parameters
Search audit events
Search audit events
DATADOG_MCP_SEARCH_AUDIT_EVENTSSearch Datadog Audit Trail events using a query string. Audit Trail monitors user activity across the Datadog platform to help maintain compliance, enforce platform governance, and build transparency, capturing audit events across configuration, access, and billing assets (monitor edits, API key creation, role changes, dashboard modifications, etc.). Use this tool when you need to filter by attributes like @evt.name, @usr.email, or @action; use list_audit_events for plain recent-events scans. Responses are capped by max_tokens and return an opaque cursor for fetching subsequent pages.Input Parameters
Search cws agent events
Search cws agent events
DATADOG_MCP_SEARCH_CWS_AGENT_EVENTSSearch and retrieve raw Workload Protection agent events — the low-level runtime security events collected by the Datadog Agent (eBPF-based) on hosts and containers. Workload Protection is also known as Cloud Workload Security (CWS) or CSM Threats; the terms “runtime security”, “runtime threats”, and “agent events” all refer to this data. Agent events include process executions, file access, network connections, and DNS queries — the raw process/file/network/DNS activity on your workloads. These are the underlying events that trigger Workload Protection security signals, so use this tool when you need the raw events themselves rather than the signals (detections) that fired on top of them. The query ‘source:runtime-security-agent’ is automatically prepended. Use the agent events schema tool to discover available fields for filtering.Input Parameters
Search datadog ci pipeline events
Search datadog ci pipeline events
DATADOG_MCP_SEARCH_DATADOG_CI_PIPELINE_EVENTSSearch and retrieve CI pipeline events from Datadog with timing, failure reasons, error messages, and retry history. Use this tool to troubleshoot CI failures, inspect structured failure details, or compare branches. For counts, rates, or statistics, use aggregate_datadog_ci_pipeline_events instead.To investigate a CI failure, search job-level events with: @git.commit.sha:<current_sha> @git.branch:<current_branch> @ci.status:error and ci_level=job.Response columns vary by ci_level:- pipeline: start, end, pipeline_name, pipeline_id, status, duration_seconds, branch
- stage: start, end, pipeline_name, stage_name, status, duration_seconds
- job: start, end, pipeline_name, job_id, job_name, status, duration_seconds, @error.message, @error.domain, @error.subdomain
- step: start, end, pipeline_name, step_name, status, duration_seconds
Input Parameters
Search datadog dashboards
Search datadog dashboards
DATADOG_MCP_SEARCH_DATADOG_DASHBOARDSList and retrieve information about Datadog dashboards. This tool helps discover available dashboards, their IDs, titles, and underlying queries. Use this tool when you need to find specific dashboards, get an overview of all dashboards in your Datadog account, or find important logs+metrics queries in dashboards.Input Parameters
Search datadog database plans
Search datadog database plans
DATADOG_MCP_SEARCH_DATADOG_DATABASE_PLANSSearch and retrieve Database Monitoring (DBM) query execution plans from Datadog. Query execution plans show how the database engine executes queries, including index usage, join strategies, and cost estimates. Use this to analyze query performance and identify optimization opportunities.Input Parameters
Search datadog database samples
Search datadog database samples
DATADOG_MCP_SEARCH_DATADOG_DATABASE_SAMPLESSearch and retrieve Database Monitoring (DBM) query samples from Datadog. Query samples represent individual query executions with performance metrics, allowing you to analyze database activity patterns, identify slow queries, and investigate database performance issues.Input Parameters
Search datadog entities
Search datadog entities
DATADOG_MCP_SEARCH_DATADOG_ENTITIESSearch Datadog services through the entity graph, including service ownership and direct upstream or downstream relationships. Prefer this tool over searching telemetry, monitors, dashboards, or other resources when the request is about service identity, catalog ownership, dependencies, or services owned by the current user’s teams. Use entity_type=service directly for ordinary service lookup and dependency questions; kind: is added by the server. Ref, type, and type-specific identity fields are always returned, so omit fields for name-only discovery. Treat an unqualified list or dependency request as complete unless the user asks for a page or sample. Follow page_next_cursor from METADATA and each truncated relationship’s next_cursor until complete. Set owned_by_current_user_teams=true instead of inferring the user’s teams from telemetry. Query supports boolean expressions such as name:chrono OR owner:idp. Use exact name:value when the user supplies a concrete internal service name; do not broaden it with wildcards. Use name:value* for prefix requests. Use name:value and return candidates for contains or ambiguous requests. Contains results are ordered, not relevance-ranked; if they are truncated, narrow the query or ask the user to clarify instead of treating the first page as the best matches. For a dependency question with no direction, request both upstream_services and downstream_services and keep the directions separate. Service ownership is returned as owner; the legacy term team is accepted as an input alias.Input Parameters
Search datadog error tracking issues
Search datadog error tracking issues
DATADOG_MCP_SEARCH_DATADOG_ERROR_TRACKING_ISSUESSearch Error Tracking Issues from Datadog. Use this tool to search errors across data sources (RUM, Logs, Traces, …). Returns groups of errors (“Issues”), along with the number of times they occurred within the given time range (“total_count”). The Issue’s ID (“issue_id”) can be used as “issue.id” or “@issue.id” in Datadog query syntax. Use the get_datadog_error_tracking_issue tool to fetch the full details of an Issue.Input Parameters
service:my-service, version:v123, application.id:4066224f-05ba-4311-bc79-1101be82ec71, env:production, view.url_path:*/checkout/*. Use @ prefix for custom attributes, quotes for spaces, wildcards (*), ranges ([100 TO 500]), and boolean operators (AND, OR, NOT). If left empty, all Issues will be returned. IMPORTANT: free-text search uses full-word matching — dots (.) are NOT word separators (foo.bar is one token, bar alone matches nothing). Wrap partial terms in wildcards or target the attribute: error.message:*bar*.Search datadog events
Search datadog events
DATADOG_MCP_SEARCH_DATADOG_EVENTSSearch and retrieve raw Datadog events (deployments, alerts, system activities, infrastructure changes, etc.). Do NOT use for counts, aggregations, or grouped analysis — use aggregate_events instead. Best for: inspecting individual events, reading event titles/messages/tags, and exploring event patterns before deciding how to aggregate them. Add a ‘source’ only when the question names a kind of event: deploys and other tracked changes: ‘source:change_tracking’, not ‘source:kubernetes’, which returns events but not deploys a deployed version Datadog detected as regressing: ‘source:deployment_analysis’ a monitor firing or recovering: ‘source:alert’ monitor, downtime and mute edits: ‘source:monitor_audit_event’ cloud resource changes: ‘source:resource_changes’ Audit Trail, DORA and Synthetics results are near-absent from the feed and have their own products; tell the user rather than searching events. To see which sources this org has, call aggregate_events with query '' over ‘now-7d’, computes [{“field”:"",“aggregation”:“count”,“output”:“n”}] and group_by {“fields”:[“source”]}.Input Parameters
Search datadog forms
Search datadog forms
Search datadog hosts
Search datadog hosts
DATADOG_MCP_SEARCH_DATADOG_HOSTSExplore Datadog hosts inventory with SQL. Queries run against the virtual ‘hosts’ table backed by “dd.hosts” (Advanced Query API), which exposes hostname, hostname_aliases (text[]; use hostname_aliases[1]), tags (hstore map; use tags->‘key’), cloud_provider, resource_type, instance_type, os, os_version, agent_version, memory_mib, cpu (hstore map; use cpu->‘key’), kernel (hstore map; use kernel->‘key’), sources (text[]; use sources[1]), modification_detected_at (timestamp). DDSQL notes: DDSQL (Datadog SQL) is a PostgreSQL subset: every non-aggregated SELECT column must appear in GROUP BY, SELECT aliases cannot be reused in WHERE/GROUP BY/HAVING (repeat the full expression instead, e.g., GROUP BY DATE_TRUNC(‘hour’, timestamp) not GROUP BY hour), and only declared table columns may be referenced. Use the -> operator or json_extract_path_text (cast as needed) for JSON access. Avoid unsupported constructs like ANY(), ->>, QUALIFY, information_schema, and current_timestamp. Column names containing special characters like ’@’ must be quoted (e.g., SELECT “@foo” FROM logs).Input Parameters
Search datadog incidents
Search datadog incidents
DATADOG_MCP_SEARCH_DATADOG_INCIDENTSSearch Datadog incidents. Default sort: newest first. Supports filtering by state, severity, title, team, creation time, and more. Use semantic_query for natural-language search over AI-generated incident summaries. Prefer query first; only add semantic_query when query by keyword and metadata filters aren’t sufficient to answer the question.Input Parameters
query (state, severity, time range, commander, service). Do NOT combine with keyword search in query — if the user’s question is keyword-shaped, use query alone.Search datadog k8s resources
Search datadog k8s resources
DATADOG_MCP_SEARCH_DATADOG_K8S_RESOURCESSearch for Kubernetes resources. Use this tool instead of kubectl to determine the state of Kubernetes resources (for example, Kubernetes deployments or pods). This tool is preferred over kubectl because it does not require local cluster access, works across all clusters, and returns enriched data with tags.Input Parameters
team:$team. The $team placeholder will be automatically replaced with the team(s) the user belongs to. If the user belongs to multiple teams, they will be ORed together (e.g., team:(container-app OR kubernetes-experiences)). All tag values are lowercase. Examples: Pods in orchestrator namespace with service orchestrator-writer: service:orchestrator-writer kube_namespace:orchestrator Ongoing deployments in general2 cluster: kube_rollout_status:inprogress kube_cluster_name:general2 CrashLoopBackOff pods in us1.prod.dog datacenter from the blue team: datacenter:us1.prod.dog pod_status:crashloopbackoff team:blue Find all pending pods from deployment orchestrator-query in cluster hypno namespace orchestrator : pod_status:pending kube_deployment:orchestrator-query kube_cluster_name:hypno kube_namespace:orchestrator Namespaces not from my team (using placeholder): -team:$team Failed deployments in billing namespace OR service billing123: (kube_rollout_status:(failed OR recentlyfailed) kube_namespace:billing) OR service:billing123 Deployments containing “sublime”: kube_deployment:sublime DatadogPodAutoscaler custom resources in prod cluster (kind=cr): kube_crd_kind:datadogpodautoscaler kube_cluster_name:prod Between January 1st 2026 and January 15th 2026 (EST, UTC-5): field#metadata.creationTimestamp:>=1767243600 AND field#metadata.creationTimestamp:<=1768453200service,team). Supports tags only (not labels, annotations, metrics, or fields): env, service, version, team, kube_cluster_name, kube_namespace, app, region, datacenter, etc. When set, returns aggregated groups with group_name and child_count instead of individual resources. Default: empty (no grouping).team,service,env. Use * to return all tags, but note that * can significantly increase response size and cause truncation — prefer specifying individual tag keys when possible. Default: empty (no tags included).Search datadog logs
Search datadog logs
DATADOG_MCP_SEARCH_DATADOG_LOGSSearch and retrieve raw log entries or log patterns. Do NOT use for counting or aggregations — use analyze_datadog_logs instead. Best for: viewing raw logs, discovering patterns (use_log_patterns=true), and discovering custom attributes via extra_fields for use as extra_columns in analyze_datadog_logs. Response shape (when extra_fields is set, output is YAML): three buckets — (1) top-level fields like env/host/service queried bare (env:prod); (2) attributes: map with source-prefixed keys — custom.X and attributes.X are queried as @X (strip the bucket prefix), but error.X keeps its prefix as @error.X because error is a real top-level attribute; (3) tags: list of key:value strings queried bare. Load the datadog/logs skill for the full key-translation table.Input Parameters
Search datadog metrics
Search datadog metrics
DATADOG_MCP_SEARCH_DATADOG_METRICSList available metrics in Datadog with optional filtering by name and tags. Set use_cloud_cost=true to search Cloud Cost Management metrics.Input Parameters
Search datadog monitors
Search datadog monitors
DATADOG_MCP_SEARCH_DATADOG_MONITORSList and retrieve information about Datadog monitors. This tool helps discover monitors, their status, configuration, and alerts. Use this tool when you need to find monitors for investigation, management, or analysis purposes.Input Parameters
Search datadog notebooks
Search datadog notebooks
DATADOG_MCP_SEARCH_DATADOG_NOTEBOOKSSearch Datadog notebooks. Use this tool when you need to find notebooks for investigation or monitoring purposes. Results can be filtered, for example by author, and sorted. This tool returns snippets of the original notebook. To fetch the entire notebook, use the get_datadog_notebook tool.Input Parameters
Search datadog rum events
Search datadog rum events
DATADOG_MCP_SEARCH_DATADOG_RUM_EVENTSSearch and retrieve raw Datadog RUM events using advanced query syntax. Do NOT use for counts, aggregations, or grouped analysis. Best for: inspecting individual RUM events, debugging specific user experience issues, exploring available event attributes in raw or detailed_output responses before deciding what to aggregate. Supports filtering by event types (session, view, action, error, resource, long_task, vital, operation), user attributes, performance metrics, and more. Results include detailed event data for analysis.Input Parameters
now (e.g. now, now-5m). Defaults to nownow- (e.g. now-15m, now-1h, now-1d, now-7d, now-30d). Defaults to now-7d@view.loading_time, @action.loading_time, @resource.duration) are in nanoseconds (1s = 1e9). Common patterns: @type:error (errors only), @type:view @view.loading_time:>5000000000 (slow page loads, >5s), @type:operation @operation.status:failure (failed operations), @application.name:"My App" status:error (app-specific errors), @user.id:123 (specific user), @view.url:*/checkout/* (checkout pages), @browser.name:Chrome (browser-specific), env:production (environment). Use @ prefix for attributes, quotes for spaces, wildcards (*), ranges ([100 TO 500]), and boolean operators (AND, OR, NOT). IMPORTANT: free-text search uses full-word matching — dots (.) are NOT word separators (foo.bar is one token, bar alone matches nothing). Wrap partial terms in wildcards or target the attribute: @error.message:*bar*.Search datadog sdk
Search datadog sdk
DATADOG_MCP_SEARCH_DATADOG_SDKRun JavaScript against the official SDK and code-exec extension catalog available to execute_code. The catalog contains only operations available to the current user and sandbox policy. Its data stays inside the sandbox; only the value you return enters the conversation.Quick start: filter the catalog.operations array, then look up type declarations in the catalog.types record by type ID.search(...) helper. catalog.operations is an array; catalog.types is a record keyed by type ID, not an array.Your code runs as the body of an async function. Write plain JavaScript, not TypeScript, and use return to return JSON. There is no dd, package loader, network, or Datadog API access in this metadata-only sandbox.Catalog operations have one of two honest surfaces. Official SDK operations use version, api, and method through @datadog/datadog-api-client. Extension operations use surface: "code-exec" plus their exact module, export, and method through the sandbox-only @datadog/code-exec package. Do not translate either surface to dd.<namespace>; product API/helper namespaces are not exposed on dd.For example, an operation with version: "v2", api: "SpansApi", and method: "aggregateSpans" is called as:describe, search, continuation callback, or executable next value. Use normal array/object traversal.Search catalog.operations to choose an available operation. Before writing execute_code, return the selected operation together with a bounded closure of its typeRefs. This gives you the exact request and response declarations plus endpoint-specific usage notes in one call. Do not return the complete operations or types collections.Use this helper to collect a bounded type closure while following inheritance, unions, and nested request/response models:typeRefs in the same program; you don’t need to know operation or type IDs before the search runs. Wrap a single find result directly with this helper before returning it; for filter results, map over them instead, for example: matches.map((operation) => describeOperation(operation)).execute_code call. For broad matches, lower maxTypes or maxChars, return only root types, or narrow the operation search with filter, map, and slice.Input Parameters
Search datadog security findings
Search datadog security findings
DATADOG_MCP_SEARCH_DATADOG_SECURITY_FINDINGSFallback tool for retrieving full security finding details. Prefer analyze_datadog_security_findings (with get_datadog_security_findings_schema) for most findings analysis tasks. Use this tool ONLY when: 1) analyze_datadog_security_findings fails, or 2) you need complete finding details not available via SQL. Returns full finding objects which consume more context than SQL aggregations. DEEP LINKS: Always link to findings using the id field — format: <deep_link_base_url>/security/finding/<id>. The correct base URL is in every response as ‘deep_link_base_url’. Tip: most users want open findings — include ‘@status:open’ in your filter unless specifically asked for all statuses.Input Parameters
page to the value returned in the previous call.Search datadog security ioc indicators
Search datadog security ioc indicators
DATADOG_MCP_SEARCH_DATADOG_SECURITY_IOC_INDICATORSList IoC Explorer indicators (IPs, domains, URLs, file hashes) matched against threat intel feeds. Returns IoC indicators, not security signals; signal_count is contextual (signals that referenced the indicator). Default sort is score desc, ties broken by signal_count then log_count. Pair with get_datadog_security_ioc_indicator for full detail and update_datadog_security_ioc_indicator_triage to mark reviewed.Input Parameters
field:value clauses joined with AND / OR. Score requires numeric ranges: Low score:[0 TO 3], Medium score:[4 TO 6], High score:[7 TO 8], Critical score:[9 TO 10]. Triage clauses: triage_state:not_reviewed/reviewed and worked_by:<handle>. Examples: indicator:1.2.3.4, categories:residential_proxy AND score:[7 TO 8], triage_state:not_reviewed.Search datadog security signals
Search datadog security signals
DATADOG_MCP_SEARCH_DATADOG_SECURITY_SIGNALSFilter and list security signals from Datadog Security Monitoring matching criteria (status, time range, rule type, severity, service). DO NOT use this tool for counts, aggregations, top-N, breakdowns, or trends — use analyze_datadog_security_signals instead. For a single signal by ID — use get_datadog_security_signal. IMPORTANT: If the user has NOT specified a signal product (Cloud SIEM / Log Detection, App & API Protection / Application Security, or Workload Protection / Workload Security), ASK them if they want to specify the product or rule type before calling this tool. IMPORTANT: Before using this tool, call get_datadog_security_signals_schema first to discover available fields for filtering and field selection. Filter signals by product with @workflow.rule.type: “Log Detection” (Cloud SIEM, from logs/audit events), “Application Security” (App & API Protection, from web spans), “Workload Security” (Workload Protection, from agent events on hosts). By default, only essential fields are returned to minimize response size. Use ‘fields’ to request specific additional fields, or ‘full_signal: true’ for complete data.Input Parameters
page to the value returned in the previous call.page or increase the value of max_tokens. Default is 50000Search datadog slos
Search datadog slos
Search datadog spans
Search datadog spans
DATADOG_MCP_SEARCH_DATADOG_SPANSRetrieve raw Datadog APM spans matching a query. Do NOT use for counts, aggregations, or grouped analysis — use aggregate_spans instead. Best for: inspecting individual spans, debugging request flows and failures, and discovering span fields/attributes, including via custom_attributes, that you may want to aggregate or group by with aggregate_spans. IMPORTANT: When the user asks for ‘security traces’, ‘AppSec traces’, ‘AAP traces’, ‘security activity’, or ‘security signals on traces’, the query MUST start from @appsec.security_activity:*. Do NOT substitute keyword-based guesses like service:*security*, resource_name:*auth*, @http.status_code:401, etc. — those do not identify security traces. Application & API Protection (AAP) spans carry these standard attributes (all strings): @appsec.security_activity (<category>.<type>, e.g. attack_attempt.sql_injection, business_logic.users.login.failure; multi-valued when multiple rules match); @appsec.category (top-level classification, e.g. attack_attempt, business_logic); @appsec.type (specific threat/event type, e.g. sql_injection, xss, users.login.failure); @appsec.rule_id (AAP rule that matched, e.g. crs-942-100; multi-valued); @appsec.blocked (true/false, whether AAP blocked the request). Use these attributes to narrow AppSec queries (e.g. @appsec.category:attack_attempt, @appsec.type:sql_injection, @appsec.blocked:true). The response includes a traces_explorer_url for the overall query. To link to an individual trace in the Datadog UI, use the pattern: <base_url>/apm/trace/<trace_id> (e.g. https://app.datadoghq.com/apm/trace/abc123). The base_url for the user’s org is available in the response metadata.Input Parameters
type:(http OR rpc). Spaces should be escaped to allow regex expressions to work correctly; for example @error.message:remote\ connection\ *. Durations should be specified in nanoseconds; for example, to search for spans with a duration greater than 5ms, use @duration:>5000000. For ‘security traces’ / AppSec / AAP requests, the query MUST include @appsec.security_activity:* (AND-ed with any other user-specified filters); refine with @appsec.category, @appsec.type, @appsec.rule_id, or @appsec.blocked when the user specifies a class of threat, rule, or block status. Examples: service:nginx status:error, trace_id:7d5d747be160e280504c099d984bcfe0, status:error AND service:(foo OR bar), @appsec.security_activity:* service:payments, @appsec.security_activity:* @appsec.category:attack_attempt @appsec.blocked:trueSearch datadog spreadsheets
Search datadog spreadsheets
Search datadog test events
Search datadog test events
DATADOG_MCP_SEARCH_DATADOG_TEST_EVENTSSearch individual Datadog test events with execution metadata, error messages, stack traces, retry history, and flaky status. Use aggregate_datadog_test_events for counts, rates, and statistics. Keep page_limit small because each event can be large. If unsure whether a facet exists or needs an @ prefix, read the datadog://mcp/ci-test-facets resource.Input Parameters
Search datadog workflow actions
Search datadog workflow actions
DATADOG_MCP_SEARCH_DATADOG_WORKFLOW_ACTIONSSearch the Datadog Workflow Automation action catalog. Actions are the building blocks of workflow steps. Each result exposes actionId; pass it to get_datadog_workflow_action and use the same value as the workflow step’s actionId.Use query to search bundle names/integrations, action titles, keywords, and descriptions. Results are ranked by relevance. If query is omitted or empty, this returns the first maxResults actions visible to the org, sorted by actionId. That empty-query response is a lightweight catalog sample, not a curated recommendation list. Use maxResults to control how many sample or matching actions are returned.Search may append the HTTP action with score 0 when no stronger native result fills maxResults. Prefer a native action when it satisfies the request, and treat HTTP as a fallback rather than an equally relevant match.Search results are for discovery only. Before adding an action to a workflow spec, call get_datadog_workflow_action with its actionId to retrieve the authoritative action contract.When deriving query from a user request, pass a concise phrase for the desired catalog operation, service, and resource. Omit surrounding scaffolding such as “add a query to”, “create a query that”, or “create a workflow step to”. For example, use “list S3 buckets” instead of “create a query that lists S3 buckets.”For general-purpose workflow actions, search these bundles directly: com.datadoghq.datatransformation for expressions and JavaScript or Python data transformations; com.datadoghq.core for conditions, branches, loops, variables, and waits; and com.datadoghq.dd.apps_datastore for persistent workflow data.Input Parameters
Search data entities
Search data entities
DATADOG_MCP_SEARCH_DATA_ENTITIESSearch for data entities in the data catalog.Parameters:- name: Entity name to search for. Supports wildcards anywhere in the value: prefix (stg_), suffix (raw), and substring/infix (orders, fct*_monthly).
- text: Full-text search across entity name, type, and all attribute values. All words must match. Use this to find entities containing a substring (e.g. text=“orders” finds tables, columns, and other entities whose name or attributes mention “orders”). Can be combined with other filters.
- entity_type: Type of entity (default “table”). Valid values are the entity_type names from the catalog schema (call get_data_catalog_schema to discover them). Use * to match any type.
- platform: Filter by warehouse platform (e.g. “snowflake”, “bigquery”, “databricks”).
- schema: Filter by schema name.
- database: Filter by database name.
- account: Filter by account identifier.
- limit: Max results (default 50, max 500).
- with_attrs: If true, include all custom attributes in the response (default false).
- query: Raw AASTRA query for advanced use (OR, negation, grouping). Overrides all other filters.
name:orders OR display_name:orders”.Input Parameters
Search dora events
Search dora events
DATADOG_MCP_SEARCH_DORA_EVENTSSearch DORA deployments or merged-and-deployed pull requests, or fetch one event by ID. For DORA trends and aggregates such as deployment frequency, change lead time, failure rate, and recovery time, use aggregate_dora_events instead. Pull-request search is only for deployed PRs; it is not an open-PR or review-status search.Input Parameters
Search llmobs spans
Search llmobs spans
DATADOG_MCP_SEARCH_LLMOBS_SPANSSearch for LLM Observability spans. Entry point for trace analysis — use it to find spans before drilling in with get_llmobs_trace.Prefer structured parameters (ml_app, tags, span_kind, span_name) over the raw query string — they handle quoting and escaping automatically. Reach for query when you need OR/NOT, wildcards, ranges, or to filter on unindexed fields like @meta.metadata.user_id:"u_1234".Use cases:- Recent traces for an ML app: set
ml_app - Errors: set
queryto@status:error - Tag with a colon/UUID value: set
tagsto{"conversation_id": "5b8d6ce1-..."}— no escaping needed - Filter by unindexed metadata:
query="@meta.metadata.user_id:\"u_1234\""(server-side) - Agent traces: set
span_kindtoagentandroot_spans_onlyto true - Spans where a specific eval ran:
query="@evaluation.\"my-eval-name\".value:*"(works for all eval types — boolean, score, categorical, json)
service, intent, llm_info (when present), and input/output/expected_output/metadata as ContentPreview envelopes. A preview has kind (value|messages|metadata), a size (chars for strings, count for arrays/maps), and a sampled preview. Each result also includes a trace_url — a ready-to-use deep link to that trace in /llm/traces. Echo trace_url verbatim when surfacing trace links to the user; do NOT construct your own /llm/traces URL (the LLMObs UI uses ?query=trace_id:<id>, not the APM ?traceID=<id> convention). One search typically gives enough context to answer discovery questions in a single round-trip. For the full payload of a specific field, call get_llmobs_span_content; for the full metadata map, call get_llmobs_span_details.Typical workflow: search_llmobs_spans → get_llmobs_trace → get_llmobs_span_details → get_llmobs_span_contentInput Parameters
:, ., spaces, or hyphens work as-is — no escaping required. Each pair becomes @tags:"key:value" under the hood. Example: {"conversation_id": "5b8d6ce1-5a4a-47d3-89df-25688384b62e", "service.namespace": "voice"}.:, ., spaces, or special chars MUST be double-quoted. Wildcards */? work outside quotes only. Prefer structured params (tags, ml_app, span_kind, span_name) — they quote for you. ✓ Correct: - @tags:"conversation_id:5b8d6ce1-5a4a-47d3-89df-25688384b62e" - @ml_app:"voice-agent" @status:error - @meta.metadata.user_id:"u_1234" - @name:generate* (wildcard outside quotes) - @metrics.total_tokens:[100 TO 500] - (@status:error OR @status:warning) - @evaluation."my-eval-name".value:* (spans where a specific eval ran — use this path for ALL eval types including json; do NOT use the legacy @evaluations.custom.* path) ✗ Rejected by parser: - @tags:conversation_id:5b8d6ce1-... (value has :, must be quoted) - @ml_app:voice agent (space unquoted) Operators: AND is implicit (space), OR must be uppercase, - prefix = NOT. Ranges: [a TO b] inclusive, {a TO b} exclusive, * for open ends. Always combined with @event_type:span. On parse failure you get the verbatim grammar message (with line/char position), the syntax rules, and a list of canonical examples — read those and retry.Search ndm devices
Search ndm devices
DATADOG_MCP_SEARCH_NDM_DEVICESSearch SNMP-monitored network devices (routers, switches, firewalls) in Datadog NDM. Use to investigate device health, interface bandwidth saturation, LACP/LAG/port-channel issues, topology neighbors (LLDP/CDP), QoS queue drops, or discover devices by vendor/location/type. Use search_ndm_devices first to get device_id values, then get_ndm_device for full details or search_ndm_interfaces for interface status.To map a WiFi BSSID / radio MAC address (e.g. from wifi metrics tagged with ‘bssid’) to the access point broadcasting it, set the bssid argument (colon form ‘aa:bb:cc:dd:ee:ff’); the response is the access point (device_type access_point) or wireless controller (wlc) device(s). An empty result means the BSSID is not mapped to an NDM-managed access point.Input Parameters
Search ndm interfaces
Search ndm interfaces
DATADOG_MCP_SEARCH_NDM_INTERFACESGet all network interfaces (e.g., GigabitEthernet0/0/1, Vlan100) for a device. Use this to troubleshoot connectivity by checking interface status (up/down/warning), identify problematic interfaces during outages, get IP address assignments for topology mapping, or audit interface configuration.Workflow: Use search_ndm_devices first to get the device_id, then use this tool to check interface status.The device_id parameter is a device identifier like ‘goxzksskg7ly3w6’ from search_ndm_devices results.Set include_ip_addresses to true to include IP addresses for each interface. This adds detail but increases response size for devices with many interfaces.Returns: JSON with device_id, interfaces array (interface_id, name, index, status, description, alias, mac_address, optionally ip_addresses), and summary object (total_count and status_counts). The summary.status_counts shows how many interfaces are up/down/off/warning - useful for quick health checks. Returns all interfaces in a single response (no pagination).Input Parameters
Search network device configurations
Search network device configurations
DATADOG_MCP_SEARCH_NETWORK_DEVICE_CONFIGURATIONSSearch NDM network device configuration snapshots (running config, startup config) for change tracking, config drift detection, or compliance auditing. Returns config metadata and IDs — use get_network_device_configuration to retrieve full config content, or diff_network_device_configurations to compare two snapshots. Also returns active_running_config_id for the device. Requires a device_id from search_ndm_devices.Input Parameters
Search pr insights
Search pr insights
DATADOG_MCP_SEARCH_PR_INSIGHTSRetrieves issues blocking a pull request to help resolve and fix problems. Provides insights on failed tests, flaky tests, code quality problems, security vulnerabilities, and failed CI jobs.Input Parameters
Search replays
Search replays
DATADOG_MCP_SEARCH_REPLAYSSearch Datadog Session Replay recordings and return a list of sessions with replay links. Only returns sessions that have a replay recording available.Two modes: • Session filter mode (default): Filter replays by session attributes such as user identity, device, error count, or any RUM facet. Use filter with Datadog search syntax, or leave it empty to get the most recent replays. • Journey search mode: Find replays where users followed a specific sequence of events. Provide steps as an ordered array of facet/value pairs (e.g. [{“facet”:“@view.name”,“value”:“/home”},{“facet”:“@action.name”,“value”:“Click Checkout”}]). Optionally add filter to restrict all funnel events to a global RUM condition.After finding sessions of interest, call get_replay_summary with the session_id to get an AI-generated play-by-play of what the user did during that session.If you have not already done so in this conversation, invoke the datadog/session-replay skill first to learn how to discover the correct facet keys and values for your query.Input Parameters
Search rum applications
Search rum applications
DATADOG_MCP_SEARCH_RUM_APPLICATIONSSearch RUM applications in the organization. Returns application_id (UUID), name, type, is_active, rum_event_processing_state (ALL/ERROR_FOCUSED_MODE/NONE), product_analytics_retention_state (MAX/NONE), tags, and creator_email. Use this to discover application_id values required by RUM tools. Filter by name, application_id (exact match), and/or creator_email (substring match). By default only active applications are returned (active_only=true); pass active_only=false to include inactive ones.Input Parameters
Search rum metrics
Search rum metrics
DATADOG_MCP_SEARCH_RUM_METRICSSearch the organization’s RUM metrics. Two kinds share the same shape: “custom” metrics are user-defined timeseries computed from RUM events, and “ootb” metrics are Datadog-predefined (server-managed). Omit type to return both with a source discriminator on each row.Examples: (no params) -> list every metric id in the org (custom + ootb) type=“custom” -> list only user-defined metrics type=“ootb” -> list only Datadog-predefined metrics type=“ootb”, application_id=“<uuid>” -> include which OOTB tags this app actually attaches name=“checkout” -> find metric ids containing “checkout” name=“dashboard”, include_full_details=true -> inspect filter and compute for dashboard-related metrics event_type=“error” -> list every error-event metric name=“latency”, event_type=“view” -> view-event metrics about latencyLIMITATIONS:- Read-only. To create or update: use upsert_rum_metric. To delete: use delete_rum_metric.
- Returns the metric definition (filter, compute, group_by_tags), not its values or ingestion volume.
- name is substring, not regex or wildcard. Omit it to list every metric.
Input Parameters
Search rum operations
Search rum operations
DATADOG_MCP_SEARCH_RUM_OPERATIONSSearch or list RUM operations in the organization. Discovers all operations (SDK-instrumented and UI-configured) via the rum.measure.operation metric, then enriches with metadata (id, display_name, tags) from configured operations. Operations only observed via the SDK have no id. Returns each operation’s id (configured ops only), name, display_name, application_id, and tags. The query is a case-insensitive substring match on the operation name. from/to/lookback default to the last 7 days and control the metric time window.Use this tool to discover or confirm an operation before investigating it: call it first to confirm an operation exists and to get its operation_id/application_id before get_rum_operation_insights or delete_rum_operation — a typo’d or nonexistent name silently returns empty results from those tools, and resolving by name here avoids investigating or deleting the wrong operation.Input Parameters
Search rum retention filters
Search rum retention filters
DATADOG_MCP_SEARCH_RUM_RETENTION_FILTERSSearch RUM retention filters for an application. Retention filters control which RUM events are indexed and retained. Provide application_id to list filters for that application, optionally narrowed by name (case-insensitive substring), event_type (one of session, view, action, error, resource, long_task, vital, operation), or enabled_only. Results are paginated client-side: use limit (default 50, max 100) with offset (zero-based, default 0) to walk through matches. The response is {filters, total, hasMore, nextOffset}: total is the post-filter count before paging so callers know the full match size; when hasMore is true, pass the returned nextOffset back as offset to retrieve the next page. This tool is read-only. To create a filter use append_new_rum_retention_filter; to update one in place use update_rum_retention_filter; to change the evaluation order use reorder_rum_retention_filters; to remove one use delete_rum_retention_filter. For questions about how filters evaluate events, permanent filters, or cross-product APM traces filters, call load_datadog_skill with skill_name=datadog/rum and resource_path=references/retention_filters.md. For debugging why a session was or wasn’t retained, auditing filter ordering, or suggesting filter layouts, call load_datadog_skill with skill_name=datadog/rum and resource_path=references/retention_filters_best_practices.md.Input Parameters
Serverless onboarding
Serverless onboarding
DATADOG_MCP_SERVERLESS_ONBOARDINGStep-by-step instructions for instrumenting serverless workloads with Datadog. This tool helps configure Datadog metrics, server-side APM tracing, and logs for serverless platforms such as AWS Lambda, Vercel, GCP Cloud Run, GCP Cloud Run functions (Gen 2), and Azure Container Apps. Asking to monitor or instrument any of these workloads is enough to start this flow. This tool does not set up browser-side RUM or error tracking. You must first review the user’s project and fill out as many arguments as possible before calling this tool. Use serverlessComputeType gcp-cloud-run for Cloud Run services (containers); use gcp-cloud-run-functions for Cloud Run functions Gen 2 (dedicated flow with Gen 2 confirmation); use azure-container-apps for Azure Container Apps. IMPORTANT: For GCP Cloud Run and Azure Container Apps, this tool will ask you mandatory questions before generating any code. You MUST answer all questions before proceeding.Input Parameters
Source map uploads
Source map uploads
DATADOG_MCP_SOURCE_MAP_UPLOADSStep-by-step instructions for configuring source map uploads for a project to Datadog. You must first review the user’s project and fill out as many arguments as possible before calling this tool. Only call this tool if the user’s project has a supported bundler.Input Parameters
Studio onboarding
Studio onboarding
DATADOG_MCP_STUDIO_ONBOARDINGStep-by-step instructions for adding Datadog Studio to a project. You must first review the user’s project and fill out as many arguments as possible before calling this tool. Check project files and dependencies to determine the argument values, focusing on dependency files, build configuration files, and project structure. Only provide values you can substantiate from the user’s files. If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.Input Parameters
Submit llmobs experiment events
Submit llmobs experiment events
DATADOG_MCP_SUBMIT_LLMOBS_EXPERIMENT_EVENTSSubmit evaluation-metric events to an existing experiment. Each metric records a judged value and, when a span_id is provided, attaches to that experiment span.Required per metric: label, metric_type, and the value field matching the type — categorical_value (categorical), score_value (score), boolean_value (boolean).span_id is optional; provide it to attach the metric to a specific experiment span (use list_llmobs_experiment_events to discover span IDs).metric_source is optional (custom | summary); it defaults to “summary” when no span_id is given and “custom” otherwise.timestamp_ms must be within the last 24 hours and not in the future; it defaults to now if omitted.Returns the number of metrics accepted.Input Parameters
Submit mcp feedback
Submit mcp feedback
DATADOG_MCP_SUBMIT_MCP_FEEDBACKSubmit feedback about capabilities provided by this Datadog MCP server only. Do NOT submit feedback about other MCP servers or plugins (e.g. Atlassian, CodeSandbox, Slack, GitHub).After completing a task, briefly consider whether any Datadog MCP capability was notably unhelpful or whether the workflow was harder than it should have been. If so, submit feedback so the MCP team can improve the experience.You should submit feedback when:- A Datadog MCP capability produced wrong, misleading, or unhelpful results that impacted your ability to help the user.
- A Datadog MCP capability’s output was missing key information that would have been useful.
- You could not accomplish something the user asked for because no Datadog MCP capability exists for it.
- A Datadog MCP workflow required many steps or workarounds that could be streamlined.
- A Datadog MCP capability’s interface was confusing or its parameters were unclear.
Input Parameters
Suggest data observability monitor filters
Suggest data observability monitor filters
DATADOG_MCP_SUGGEST_DATA_OBSERVABILITY_MONITOR_FILTERSAnalyze a set of entities to find common attributes and naming patterns, then suggest monitor filter expressions that group subsets of those entities for use in monitor definitions.Pass entity IDs from prior tool results (rank_data_entities_by_lineage_degree, get_popular_warehouse_tables_by_query_frequency, search_data_entities, etc.) to discover what the most important tables have in common.The tool detects:- Shared core attributes (platform, schema, database, account) across all or subsets of entities
- Common name prefixes (e.g. “stg_”, “fact_”) and suffixes (e.g. “_raw”, “_daily”)
- Passed to search_data_entities via the query parameter to see ALL tables matching the filter
- Used as a monitor filter to cover a group of tables without naming each one
- Gather high-priority entity IDs from lineage, query activity, and coverage tools
- Call suggest_data_observability_monitor_filters with those entity IDs
- Pass a suggested filter to search_data_entities (via query param) to verify the scope
- Narrow the filter if needed (add schema, database, or name conditions)
- entity_ids: List of hex entity ID strings to analyze (minimum 2, from prior tool results).
Input Parameters
Summarize data entity lineage
Summarize data entity lineage
DATADOG_MCP_SUMMARIZE_DATA_ENTITY_LINEAGEGet aggregate statistics about the lineage graph reachable from anchor entities.Use this BEFORE get_data_entity_lineage when dealing with large or unknown graphs. It returns counts and breakdowns without the full node/edge payload, so it works on graphs of any size.Typical workflow:- summarize_data_entity_lineage to understand graph shape (total nodes, types, depth distribution)
- get_data_entity_lineage with a small max_depth (and specific anchors) to pull the actual nodes + edges for a region of interest
- get_data_entity_details for full attributes on specific entities
- anchor_entity_ids: one or more hex entity IDs (required). Use search_data_entities to find IDs.
- direction: “downstream” (default) or “upstream”. If both are needed, make two summarize_data_entity_lineage calls
- max_depth: Maximum BFS depth (default 50). Higher than get_data_entity_lineage since no payload concern.
- group_by_attrs: Attribute names to aggregate (e.g. [“platform”, “schema”, “database”]).
- include_node_types: Only include these node types. Empty = all.
- exclude_node_types: Exclude these node types (e.g. [“dbt_model”, “s3_bucket”]).
- include_edge_types: Only include these edge types. Empty = all.
- exclude_edge_types: Exclude these edge types.
- total_nodes, total_edges: aggregate counts. total_nodes INCLUDES the anchor entities themselves (they sit at depth 0).
- anchor_node_count: how many of total_nodes are the anchors you queried (depth 0).
- connected_node_count: nodes connected by lineage beyond the anchors (= total_nodes - anchor_node_count). Use this when reporting “how many dependencies/connections”, not total_nodes.
- max_depth_reached: deepest BFS level with nodes
- nodes_by_type: type → count breakdown
- nodes_by_attr: attr_name → value → count (for each group_by_attrs entry)
- edges_by_type: edge type → count breakdown
- depth_levels: per-depth summary with node counts, type breakdown, and attribute breakdown. depth 0 is the anchor entities themselves; depth >= 1 are connected lineage.
- note: human-readable summary, including the anchor-vs-connected breakdown.
Input Parameters
Sync-allocations-for-feature-flag-environment
Sync-allocations-for-feature-flag-environment
DATADOG_MCP_SYNC_ALLOCATIONS_FOR_FEATURE_FLAG_ENVIRONMENTSynchronize allocations for a feature flag in a specific environment.This tool supports FEATURE_GATE and CANARY allocations, including exposure schedules and guardrail metrics. If any existing allocation is linked to a standard experiment, use sync-experiment-allocations-for-feature-flag-environment even when editing a different allocation. This full-state sync validates every existing allocation before replacing the set.WARNING: This replaces ALL existing allocations. Use list-allocations-for-feature-flag first to preserve existing ones. Production changes take effect immediately, so verify the complete replacement before calling. If the environment requires approval, the tool returns approval_pending and the allocations remain unchanged until the suggestion is approved.A targeting-rule condition may be a saved-filter reference (saved_filter_id) instead of an inline operator/attribute/value; the two are mutually exclusive. Use list-saved-filters / get-saved-filter to find ids.Use exposure_schedule.rollout_options.scheduled_start to control when a rollout starts (applies to both CANARY and FEATURE_GATE allocations): ‘none’ (create without starting), ‘now’ (start immediately), ‘relative:<duration>’ (e.g. ‘relative:2h’), or ‘absolute:<RFC3339>’. Prefer this over the deprecated autostart field. A future value schedules the rollout to start at that time. Exception: a FEATURE_GATE allocation with experiment_id set (a standard experiment allocation) cannot be auto-started, so a future scheduled_start is rejected for it — use ‘none’ and start the experiment through its lifecycle instead. To preserve an existing schedule’s start time when resyncing other allocation fields, omit scheduled_start and echo back exposure_schedule.scheduled_start_time unchanged. For an APM Canary, preserve or set exposure_schedule.apm_retention with mode TEMPORARY and a rate greater than 0 and at most 1. This uses the deployed retention lifecycle rather than a manually managed filter.*** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach. For context on using feature flags in applications, see the datadog://feature-flags/sdk/react resource.Input Parameters
Sync-experiment-allocations-for-feature-flag-environment
Sync-experiment-allocations-for-feature-flag-environment
DATADOG_MCP_SYNC_EXPERIMENT_ALLOCATIONS_FOR_FEATURE_FLAG_ENVIRONMENTSynchronize allocations that include a FEATURE_GATE allocation linked to a standard experiment. Use this tool when the requested or existing full allocation set contains a FEATURE_GATE allocation linked to a standard experiment, even if the immediate edit targets a different allocation.WARNING: This replaces ALL existing allocations. Use list-allocations-for-feature-flag first to preserve existing ones. Production changes take effect immediately, so verify the complete replacement before calling. A targeting-rule condition may use saved_filter_id instead of inline condition fields. If the environment requires approval, the tool returns approval_pending and the allocations remain unchanged until the suggestion is approved.For a FEATURE_GATE allocation with experiment_id set, exposure_schedule.rollout_options.scheduled_start cannot be a future value (‘relative:<duration>’ or a future ‘absolute:<RFC3339>’) because it cannot be auto-started — use ‘none’ and start the experiment through its lifecycle instead. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach.Input Parameters
Synthetics test wizard
Synthetics test wizard
DATADOG_MCP_SYNTHETICS_TEST_WIZARDUse this tool to validate (preview) or create (create) a Synthetics API http test. Every test must be previewed and validated by the user before being created.Input Parameters
preview to validate the test configuration before creating a test, and then create to create the test.Test optimization onboarding
Test optimization onboarding
DATADOG_MCP_TEST_OPTIMIZATION_ONBOARDINGStep-by-step instructions for adding Datadog Test Optimization setup this project. You must first review the user’s project and this tool’s arguments (including any nested arguments) and fill out as many of them as possible before calling this tool. Check project files and dependencies to determine the argument values, focusing on dependency files and imports. Only provide values you can substantiate from the user’s files. If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer. Before calling this tool, you must first check if the user’s project has already been configured for Datadog. If it has, you should further check if the project has already been configured for Test Optimization. If it has, you should not call this tool. Use CLI utilities, such as ls and cat when checking if the project contains existing env files and viewing their contents, respectively.Input Parameters
Unarchive-feature-flag
Unarchive-feature-flag
Unarchive-saved-filter
Unarchive-saved-filter
Unblock datadog security aap denylist
Unblock datadog security aap denylist
DATADOG_MCP_UNBLOCK_DATADOG_SECURITY_AAP_DENYLISTRemove AAP (App & API Protection) denylist entry — stop blocking IP/user/user-agent. Mirrors UI “Unblock” button: POST past expiration on Security Response Entity, clears every attached response. Writes ASM_DATA + Remote Config; seconds-to-minutes propagation.Lookup: exact (entity_type, value). Case-sensitive. Call get_datadog_security_aap_denylist first if exact value unknown.Idempotent: no active match = status=noop, no error. Safe to re-run.NOT passlist / WAF exception / SIEM suppression. To shorten block instead of removing, use upsert_datadog_security_aap_denylist w/ smaller duration.Keywords: AAP, ASM, unblock, remove block, delete denylist, deblock, allow IP, allow user, allow user-agent, ASM unblock, lift block.Input Parameters
Unpublish datadog workflow
Unpublish datadog workflow
DATADOG_MCP_UNPUBLISH_DATADOG_WORKFLOWStop a Datadog Workflow Automation workflow from starting new automatic executions by unpublishing it, while preserving its base spec and any saved draft. This does not cancel executions already in progress; use cancel_datadog_workflow_instance for those.Input Parameters
Update datadog error tracking issue
Update datadog error tracking issue
DATADOG_MCP_UPDATE_DATADOG_ERROR_TRACKING_ISSUEUpdate an Error Tracking Issue in Datadog. Use this tool to change the state of an issue or update its assignee. At least one of state or assignee must be provided. The Issue ID can be obtained from the search_datadog_error_tracking_issues or get_datadog_error_tracking_issue tools.Input Parameters
Update datadog flaky test states
Update datadog flaky test states
Update datadog form
Update datadog form
DATADOG_MCP_UPDATE_DATADOG_FORMCreate a new draft version of a Datadog form, updating its schema and/or UI layout. The schema is unique, you must retrieve it using the get_form_definition_schema tool before attempting to make an update. The new version is in draft state until published with publish_datadog_form. Returns the new version’s metadata including its ID and state.Input Parameters
Update datadog monitor
Update datadog monitor
DATADOG_MCP_UPDATE_DATADOG_MONITORUpdates a SINGLE existing Datadog monitor identified by its numeric ID. Uses PATCH semantics: only the fields you provide are changed; all others are left as-is. This edits exactly ONE monitor per call — NEVER use it to bulk-edit monitors, and never loop it across a list of monitor IDs. WARNING: it can modify a live, notifying monitor (query, thresholds, message, tags, priority), and published monitors take the change immediately. ALWAYS confirm the specific change with the user first, then set confirm: true. Use search_datadog_monitors to find the monitor ID and its current configuration, and validate_monitor_definition to check a new query before updating.Input Parameters
Update datadog published analysis
Update datadog published analysis
DATADOG_MCP_UPDATE_DATADOG_PUBLISHED_ANALYSISUpdates a published analysis (also called a published dataset) by re-syncing it with the current notebook cell definitions. A published analysis is a snapshot of a computational notebook’s cells, exposed as a queryable dataset. Use this after notebook cells have changed and the published analysis needs to reflect the latest cell state.Input Parameters
Update datadog security detection rule
Update datadog security detection rule
DATADOG_MCP_UPDATE_DATADOG_SECURITY_DETECTION_RULEUpdate an existing Cloud SIEM detection rule by PUTing the supplied payload to PUT /api/v2/security_monitoring/rules/{rule_id}. PUT replaces the rule wholesale — call get_datadog_security_detection_rules first to fetch the current body, modify the fields you need to change, and submit the full object. See get_datadog_security_detection_rules_schema for the grammar. The tool automatically appends the datadog_mcp:updated tag to the rule payload. Cannot update Datadog-shipped default rules (isDefault: true on GET); returns 403 — clone the rule first to customize. On success, returns the full updated rule.Input Parameters
get_datadog_security_detection_rules with targeted fields modified.Update datadog security findings automation rule
Update datadog security findings automation rule
DATADOG_MCP_UPDATE_DATADOG_SECURITY_FINDINGS_AUTOMATION_RULEUpdate an existing security findings automation rule. Supports partial updates — only the fields you provide will be changed, other fields are preserved. Works for all rule types: mute, due_date, ticket_creation, severity_modifier. Use this to enable/disable rules, change names, update filters, or modify action parameters. Use list_datadog_security_findings_automation_rules to find rule IDs first.Input Parameters
Update datadog security ioc indicator triage
Update datadog security ioc indicator triage
Update datadog security signals triage
Update datadog security signals triage
DATADOG_MCP_UPDATE_DATADOG_SECURITY_SIGNALS_TRIAGEUpdate the triage state and/or assignee of security signals. The tool collects all matching signal IDs first, then applies updates in batches. Provide either signal_ids (for a known set of signals) or filter_query (to match signals by query). Valid states: open, archived, under_review. archive_reason is required when state is ‘archived’. Set assignee_uuid to an empty string to unassign. When the user asks to update a range of signals (e.g. all signals for a rule), first call analyze_datadog_security_signals to get the count of matching signals, then share the count and https://<org-domain>/security/signals?query=<url-encoded-filter>&from=<from>&to=<to> if the org domain is known, otherwise the relative path /security/signals?query=<url-encoded-filter>&from=<from>&to=<to> on the Datadog app before updating.Input Parameters
Update datadog security suppression
Update datadog security suppression
DATADOG_MCP_UPDATE_DATADOG_SECURITY_SUPPRESSIONUpdate an existing security monitoring suppression rule in Datadog. All fields except suppression_id are optional — only provided fields are changed. Call get_datadog_security_suppressions first to retrieve the current suppression state and its version before editing. Providing version enables optimistic concurrency control and prevents overwriting concurrent edits. Call get_datadog_security_detection_rules first to inspect the target rule(s) and build an accurate rule_query. This operation is destructive: changes take effect immediately and alter which future signals are generated.Input Parameters
Update datadog skill
Update datadog skill
DATADOG_MCP_UPDATE_DATADOG_SKILLUpdate one of your own library skills in your organization’s Skills Library — a separate, user-authored set of task guides, distinct from any built-in “Skills” your own agent tooling may already have, and distinct from Datadog’s own first-party skills (a separate, built-in set you cannot edit through this tool). The library skill is identified by slug. Only library skills you authored that are private can be updated; Shared (public) library skills cannot be edited through this tool. If this returns a “not found” result, the library skill may not exist, or it may be Shared rather than your own private one — Shared library skills must be managed in the Datadog UI. Provide only the fields you want to change; visibility cannot be changed.Input Parameters
Update datadog workflow
Update datadog workflow
DATADOG_MCP_UPDATE_DATADOG_WORKFLOWUpdate an existing Datadog Workflow Automation workflow by ID. Returns the updated workflow. A successful response confirms that the workflow was saved; it does not establish successful runtime behavior.Top-level fields are patched: provided fields change, while omitted fields remain unchanged. Spec updates create or update a saved draft; an unpublished workflow without a saved draft updates its base spec. A provided spec is the entire replacement spec, not a partial spec patch. Preserve unrelated existing steps, triggers, inputs, connections, and display data in the replacement. Use get_datadog_workflow without specTarget when the current complete value is not already known, especially before constructing a replacement spec. Use publish_datadog_workflow to publish the workflow.To retain the current layout, preserve every existing step’s display; to intentionally request automatic layout, omit display from every step.Input Parameters
Update data observability recommendation status
Update data observability recommendation status
DATADOG_MCP_UPDATE_DATA_OBSERVABILITY_RECOMMENDATION_STATUSSets the lifecycle status of a Data Observability recommendation, e.g. to mark it applied (RESOLVED) or dismissed (IGNORED) after acting on it.Obtain the id from list_data_observability_recommendations or get_data_observability_recommendation.Input Parameters
Update entity description
Update entity description
Update-environment
Update-environment
DATADOG_MCP_UPDATE_ENVIRONMENTReplace the attributes of an existing Feature Management environment. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools.Use when reconciliation against list-environments shows an existing environment needs to cover additional DD_ENV values (“will extend” outcome). To extend, read the current queries first via list-environments, append the new values, and pass the combined list.WRITE OPERATION. This is a full replace of the environment’s attributes, not a merge. Fields that already have a value must be re-supplied or they will be overwritten. Show the user the exact resulting attributes and get approval before calling. Flipping is_production=false→true has serious operational impact — confirm intent explicitly.Input Parameters
Update-feature-flag-environment
Update-feature-flag-environment
DATADOG_MCP_UPDATE_FEATURE_FLAG_ENVIRONMENTUpdate a feature flag in a specific environment by enabling/disabling it, changing the default variant, setting an override variant, or clearing an override variant. *** FEATURE FLAG DETECTION *** If users mention: flags, toggles, feature switches, A/B tests, experiments, gradual rollouts, canary releases, or say they want to ‘flag’ something, this is feature flag work and should use feature flag tools. This is a secondary tool - use after determining flag exists and implementation approach. For integration guidance, see the datadog://feature-flags/sdk/react resource.Input Parameters
Update llmobs annotation label schema
Update llmobs annotation label schema
DATADOG_MCP_UPDATE_LLMOBS_ANNOTATION_LABEL_SCHEMAReplace an annotation queue’s label schema.This is a full replacement, not a merge. Read the current schema with get_llmobs_annotation_label_schema, apply your edits to that list, and send the whole list back:- a label you leave out is removed from the queue
- a label sent with its existing
idis edited in place, keeping annotations already written against it - a label sent without an
idis a brand-new label, even if the name matches an old one — existing annotations do not follow it
label_schemas with ids assigned.Adding a required label to a queue that already has annotations leaves those annotations incomplete rather than invalid.Input Parameters
Update llmobs annotation queue
Update llmobs annotation queue
DATADOG_MCP_UPDATE_LLMOBS_ANNOTATION_QUEUEEdit an annotation queue’s name, description, or reviewer access. Only the fields you pass change; the rest keep their stored values.Returns the full updated queue.This tool cannot change labels — use update_llmobs_annotation_label_schema, which replaces the whole schema and needs care with existing label ids.Input Parameters
Update llmobs experiment
Update llmobs experiment
DATADOG_MCP_UPDATE_LLMOBS_EXPERIMENTUpdate the mutable properties of an existing experiment. Provide only the fields you want to change; omitted fields are left untouched. At least one updatable field must be provided.Use status to track lifecycle: “running” when it starts, then “completed”, “failed”, or “interrupted” when it finishes. When setting status to “failed”, pass error with a short reason.Returns the experiment ID and the list of fields that were updated.Input Parameters
Update rum operation
Update rum operation
DATADOG_MCP_UPDATE_RUM_OPERATIONUpdate a web-UI-configured RUM operation in place: the same object edited by the RUM Operations UI’s operation editor. Every field is optional except the identifier — only the fields you pass are changed; the rest keep their current value.This tool does NOT affect SDK-instrumented operations — those are defined in application code via startFeatureOperation(…) and have no backend object; this tool cannot update them. For SDK-instrumented operations, load the datadog/rum skill (load_datadog_skill) for the SDK instrumentation guidance — this tool only edits web-UI-configured operations. Use this tool only when the ask is to change how an operation is configured from the RUM Operations UI’s perspective, not “help me change my app’s code.”Identify the operation with operation_id (preferred) or name — at least one is required. When identifying by name, the match is case-insensitive and whitespace-trimmed, exactly like delete_rum_operation; use search_rum_operations first if unsure. This tool cannot rename an operation — name is only used to find it.Each of start/success/failure is a query+event_type pair: set both to replace that step, or leave both unset to keep the step as-is. Setting a query without its event_type (or vice versa) is rejected. abandonment is a tri-state boolean, not a query — omit to leave it as-is, set true to add or refresh it (derived from the effective start_query), set false to remove it.Limitations: each step is a single query only — composite steps (multiple queries combined with AND/OR at one step) and the “update” step type are UI-only features this tool does not expose. If the operation has an existing step of either kind, the update is rejected entirely (even for changes unrelated to that step) rather than silently dropping or corrupting it; edit that operation in the RUM Operations UI instead.Always confirm the exact change (which fields, new values) with the user before calling. Never update an operation speculatively. Re-invoke with confirm: true once confirmed.Input Parameters
Update rum retention filter
Update rum retention filter
DATADOG_MCP_UPDATE_RUM_RETENTION_FILTERUpdate an existing RUM retention filter’s attributes in place. Retention filters control which RUM events are indexed and retained.This changes data-retention configuration and directly affects billing. Lowering a sample_rate or disabling a filter reduces the data your org retains; raising it increases indexed volume and cost. Always confirm the exact change with the user before calling. Never modify a filter speculatively.application_id and filter_id are both required. Every attribute field is optional; only the fields you pass are changed. event_type: one of session, view, action, error, resource, long_task, vital, operation. sample_rate: 0.1 to 100 (percent of matching events retained).This tool does not reorder filters; to change the evaluation order use reorder_rum_retention_filters. Find filter IDs with search_rum_retention_filters. Updating a missing filter_id returns a not-found error. To create a filter use append_new_rum_retention_filter; to remove one use delete_rum_retention_filter.Input Parameters
Update-saved-filter
Update-saved-filter
Upsert datadog dashboard
Upsert datadog dashboard
DATADOG_MCP_UPSERT_DATADOG_DASHBOARDCreates or updates a Datadog ordered-grid dashboard. New dashboards are always ordered; widget updates are only supported on ordered dashboards. When updating widgets, prefer diff-style payloads to minimize tokens: send full definitions only for new or changed widgets, include {“id”: N} for unchanged widgets to keep, and omit existing widgets only when deleting them.Input Parameters
Upsert datadog security aap custom rule
Upsert datadog security aap custom rule
DATADOG_MCP_UPSERT_DATADOG_SECURITY_AAP_CUSTOM_RULECreate or update an AAP (App & API Protection) WAF custom rule — a user-authored in-app WAF rule that matches request traffic and monitors or blocks it. Use for “block requests that…”, “write a WAF rule”, “virtual-patch this endpoint”, “flag a business event”. A blocking rule can drop live production traffic, so only call it when the user clearly intends to create or change a rule.Omit id to create (server assigns one); pass an existing rule’s id to update. Update replaces the whole rule — fields you omit are re-sent from the current rule so nothing is silently cleared.status (default monitoring): disabled = off; monitoring = flags matches only; blocking = blocks on match (pair with action to shape the block). A business_logic rule cannot block. Blocking is NOT allowed when creating a rule: new rules must be monitoring or disabled. To make a rule block, first create it as monitoring, confirm what it matches, then update it (pass its id) to blocking — only do this when the user explicitly asks to block and approves it.category (required on create): attack_attempt, business_logic, or security_response. api_security is not yet supported. type tags the rule: attack_attempt → an attack class (sql_injection, xss, lfi, …); security_response → block_ip or block_user; business_logic → a free event name (e.g. users.login.success).A rule needs at least one condition OR a path_glob. Each condition ANDs together; a condition matches when any of its inputs satisfies the operator. scope limits the rule to services/envs (omit = all). Call get_datadog_security_aap_custom_rules first for an id and a snapshot before updating.To temporarily stop a rule without losing it, update it with status=“disabled” — it can be re-enabled later. To permanently remove a rule, use delete_datadog_security_aap_custom_rule instead.NOT Cloud SIEM detection rules (signals over logs). NOT the passlist (WAF exceptions) or denylist (blocked IPs/users).Keywords: AAP, ASM, WAF, custom rule, in-app WAF rule, blocking rule, virtual patch, block requests, monitor requests, business logic rule, disable rule, pause rule, mute rule.Input Parameters
Upsert datadog security aap denylist
Upsert datadog security aap denylist
DATADOG_MCP_UPSERT_DATADOG_SECURITY_AAP_DENYLISTAdd/refresh AAP (App & API Protection) denylist entry — block IP/user/user-agent via auto security response. Writes ASM_DATA + Remote Config; seconds-to-minutes propagation. Upsert by (entity_type, value): re-posting overwrites prior expiration + response set. NOT passlist / WAF exception / SIEM suppression.Expiration (pick ONE; mutually exclusive):- omit both fields = permanent block.
- duration = relative window, server adds to now. PREFER THIS for “block for N min/hours/days” — agents don’t know current wall-clock time. Format: Go duration (“15m”, “1h”, “24h”) or “Nd” / “Nw” (e.g. “7d”, “1w”). Must be positive.
- expiration = absolute RFC3339 future timestamp (e.g. “2026-06-01T12:00:00Z”). Use only when caller has explicit absolute target. Past = rejected; use unblock_datadog_security_aap_denylist.
Input Parameters
Upsert datadog security trace passlist
Upsert datadog security trace passlist
DATADOG_MCP_UPSERT_DATADOG_SECURITY_TRACE_PASSLISTCreate or update an AAP (App & API Protection) passlist/allowlist entry — also known as a WAF exclusion filter — that exempts traces from WAF analysis/blocking. AAP traces only; unrelated to Cloud SIEM signal suppression. Use this tool when a user asks to exclude/exempt WAF traces, allowlist an IP/service/path, or add a WAF exception. To remove an entry, use delete_datadog_security_trace_passlist.Actions:- “create”: needs “description” + “enabled”.
- “update”: partial patch keyed by “exclusion_filter_id”. Omitted fields are preserved (the tool re-sends them from the current entry, so nothing is silently cleared).
- “monitor” → Monitored: traces emitted, blocking suppressed.
- omitted on create → Unmonitored: no traces emitted.
- On update, omitting “on_match” preserves it. To move Monitored → Unmonitored, pass “on_match”:“unmonitored” (tool-only sentinel that clears the field). Don’t pass “on_match” on update unless the user explicitly wants a category change.
- ip_list: CIDR/IP strings.
- path_glob: URL path glob (e.g. “/api/v1/health”).
- parameters: query/body parameter names (dot notation for nested).
- rules_target: [{rule_id?, tags?: {category?, type?}}] — scope to WAF rules.
- scope: [{env?, service?}] — scope to services/envs.
Input Parameters
Upsert datadog spreadsheet
Upsert datadog spreadsheet
DATADOG_MCP_UPSERT_DATADOG_SPREADSHEETCreate or update a Datadog spreadsheet’s tables, sheets, and pivots in a single call. Always create pivots embedded within a sheet (in sheets[].pivots), not as standalone tabs. To delete the spreadsheet itself, use delete_datadog_spreadsheet.Before calling this tool:- Load the datadog/sheets skill — pivot placement, time_frame format, column rename cascade.
- Call get_datadog_spreadsheet_reference for each of table, sheet, or pivot you are constructing (section: “table”, “sheet”, “pivot”). For tables, also call the schema discovery tool — never invent field names.
- On update: call get_datadog_spreadsheet(spreadsheet_id) — never use a cached response, it omits fields and causes 400 errors. If is_truncated=true, retry with higher max_tokens. Copy name and time_frame verbatim. Omit array params you are not touching. For each table or pivot you include, copy its full definition verbatim and change only what you intend to modify. For sheets, cells and styles are patch-merged — send only the entries you want to add or change.
Input Parameters
Upsert data observability monitor annotations
Upsert data observability monitor annotations
DATADOG_MCP_UPSERT_DATA_OBSERVABILITY_MONITOR_ANNOTATIONSCreate, update, or extend Data Quality monitor annotations.Monitor IDs are stable request identifiers, but when a monitor name has already been resolved, use the name as the primary user-facing label and put the ID in parentheses. Never mention group_hash when it is “0”; mention a non-default group hash only when needed to distinguish multiple groups. Present annotation ranges using RFC3339 UTC timestamps, not raw Unix timestamps; retain Unix values only for tool calls.Do not ask the user for a time range merely because they omitted one. First call inspect_data_observability_monitor_annotations for the selected monitor and entity and infer the range from latest_out_of_bounds_interval. When that interval exists, proactively recommend it as the default candidate and ask whether to apply it. For recurring anomalies, propose only that latest interval unless the user explicitly asks to annotate historical occurrences or says the model is not learning a recurring normal pattern. Never combine intervals across valid or missing points. Only propose their first-to-last envelope when the user wants an ignore annotation to forget the whole history. Ask the user for a range only when inspection finds no candidate or leaves multiple materially different choices. If monitor selection is ambiguous, resolve the monitor first, then inspect it before asking about time.Choose the annotation type by its effect on future alerts:- new_baseline (“Until this happens again”): accept the current state temporarily, but alert on a comparable future change. Prefer it for a sustained level shift or a one-off episode whose recurrence should alert. Do not use it for points within bounds.
- expected_occasionally (“Until there’s a bigger anomaly”): remember this event persistently so a similar jump, drop, flatline duration, freshness delay, or percentage value is accepted and only a larger event alerts. Prefer it for valid recurring behavior that users do not want to be alerted about. Do not use it for points within bounds.
- false_negative: mark specific in-bounds behavior as anomalous because it should have alerted. Do not use it on an already out-of-bounds point.
- ignore: remove invalid or untrustworthy measurements, a bad backfill, or history that is no longer representative of expected future behavior from model history. Do not use it merely to suppress a valid alert.
Input Parameters
Upsert llmobs annotations
Upsert llmobs annotations
DATADOG_MCP_UPSERT_LLMOBS_ANNOTATIONSWrite label values onto interactions queued in an annotation queue — the graded judgement itself.Read the queue’s labels with get_llmobs_annotation_label_schema first: values are keyed by label_schema_id, and each label constrains what a valid value is (a score’s range, a categorical’s allowed strings). Passing label_name instead resolves the id for you at the cost of an extra lookup.Upsert semantics: an item without annotation_id updates your own existing annotation on that interaction, or creates one when there is none.Returns annotations (the stored result) and errors. Partial success is normal — read errors rather than assuming every item landed.These are recorded as your judgement, attributed to the calling user. State the basis for each value rather than guessing at labels you cannot evaluate, and use reasoning where the label allows it.Input Parameters
Upsert reference table rows
Upsert reference table rows
DATADOG_MCP_UPSERT_REFERENCE_TABLE_ROWSInsert new rows or update existing rows in a reference table. If a row with the same primary key already exists its values are overwritten; if it does not exist it is created. Composite primary keys are not supported. Each row must include all required schema fields including the primary key field. Use list_reference_tables to discover table IDs and schemas first.Input Parameters
Upsert rum metric
Upsert rum metric
DATADOG_MCP_UPSERT_RUM_METRICCreate or update a RUM custom metric. If the metric does not exist it is created; if it already exists its mutable fields (filter, group_by, include_percentiles) are updated.IMMUTABLE after creation: event_type, aggregation, path. To change these, call delete_rum_metric first then re-create.metric_id naming: rum.<event_type>.<description> (e.g. rum.error.checkout_errors). Must start with a letter, alphanumerics/underscores/periods only. Must not start with “rum.measure” (OOTB reserved) or “rum.investigate” (reserved prefix).uniqueness_when: required for event_type=session or view. “match” (default): count on the first event matching the filter. “end”: count when the session/view ends — use for duration or completion metrics (e.g. final LCP). Not allowed for other event types.metric_id, event_type, aggregation, and path are immutable after creation. To change these, delete the metric and re-create it. Always confirm the exact change with the user before calling. Never create or update a metric speculatively.aggregation=distribution requires path. include_percentiles only valid for distribution.group_by_path: RUM attributes to group by (e.g. [“@geo.country”,“@service”]). High-cardinality attributes (per-event IDs, raw URLs, user identifiers) warn but proceed with confirm: true — each unique value is a separate time series. Prefer bucketed forms like @view.url_path_group, and filter aggressively since even bucketed paths can be large. group_by_tag is optional: tag names are derived from the path when omitted.Examples: Count checkout errors by service: metric_id=“rum.error.checkout_errors”, event_type=“error”, aggregation=“count”, filter=“@error.resource.url:checkout”, group_by_path=[“@service”]P95 LCP by country (use “end” to capture the final LCP value at view close): metric_id=“rum.view.lcp_by_country”, event_type=“view”, aggregation=“distribution”, path=“@view.largest_contentful_paint”, include_percentiles=true, group_by_path=[“@geo.country”], uniqueness_when=“end”LIMITATIONS:- To query metric values (not definition), use get_datadog_metric or ddsql_run_query.
- To list existing metrics: search_rum_metrics with type=custom.
- To delete: delete_rum_metric.
Input Parameters
Validate dashboard widget
Validate dashboard widget
Validate datadog workflow
Validate datadog workflow
DATADOG_MCP_VALIDATE_DATADOG_WORKFLOWA read-only check of a complete candidate workflow spec. It does not create or change a workflow.Semantic invalidity returns isValid: false and validationErrors. Malformed tool arguments can still produce a tool error. Validation does not prove external credentials, permissions, or third-party runtime behavior.Input Parameters
Validate monitor definition
Validate monitor definition
Verify-onboarding-flag
Verify-onboarding-flag
DATADOG_MCP_VERIFY_ONBOARDING_FLAGVerify a client-side onboarding flag through the public Datadog CDN using the user’s own client token — the same path browser/mobile client SDKs use. Returns {ok:true, value:true, variation_key:“<served variant>”} only when the flag serves the boolean value true from the normal CDN cache. variation_key reflects whichever variant actually served true, not necessarily “enabled” — a flag created manually in the UI may name its variants differently than create-onboarding-flag’s fixed “enabled”/“disabled” shape. The client_token is sensitive: it is used only for this call, never logged, and never stored in onboarding state.