datadog-mcp: Skill for Cursor

MCP Tool Creator

This skill guides you through creating new MCP tools for the Datadog MCP server with proper typing, documentation, and architecture.

Step-by-Step Tool Creation

Step 1: Plan the Tool

Before writing code, determine:

1. Purpose: What specific task does this tool accomplish?
2. API Endpoint: Which Datadog API endpoint(s) will it use?
3. Parameters: What inputs does it need?
4. Return Type: What data structure will it return?
5. Domain: Which tool file should contain it? (logs, metrics, dashboards, apm, monitors, or new domain)

Step 2: Define TypedDict Response Structure

Create explicit types before implementation:

from typing import TypedDict, NotRequired

class ToolResponse(TypedDict):
    """Response from the new tool."""
    success: bool
    error: NotRequired[str]
    # Add specific fields for your tool
    data: list[DataItem]
    count: int
    next_cursor: NotRequired[str | None]

Step 3: Create Internal Implementation

In the appropriate tools/*.py file:

"""Module docstring describing this domain."""

from typing import TypedDict, Literal, NotRequired
from datadog_api_client.v2.api.relevant_api import RelevantApi
from datadog_api_client.v2.model.request_model import RequestModel

from ..auth import DatadogAuth
from ..utils.response import ResponseBuilder, format_error_response
from ..utils.auth import get_api_instance

# Define response types first
class ItemData(TypedDict):
    """Individual item in response."""
    id: str
    name: str
    value: int

class ToolResponse(TypedDict):
    """Complete tool response."""
    success: bool
    data: list[ItemData]
    count: int
    error: NotRequired[str]

# Implementation function
def my_new_tool(
    param1: str,
    param2: int | None = None,
    auth: DatadogAuth | None = None
) -> ToolResponse:
    """Internal implementation with business logic.

    Args:
        param1: Description of parameter 1
        param2: Description of parameter 2 (optional)
        auth: DatadogAuth instance (injected)

    Returns:
        ToolResponse with data and metadata
    """
    # Get API instance
    api_instance, auth = get_api_instance(RelevantApi, auth)

    try:
        # Build API request
        request = RequestModel(
            param1=param1,
            param2=param2
        )

        # Call API
        response = api_instance.call_endpoint(body=request)

        # Format data
        items: list[ItemData] = []
        if hasattr(response, 'data') and response.data:
            for item in response.data:
                items.append({
                    "id": item.id if hasattr(item, 'id') else "",
                    "name": item.name if hasattr(item, 'name') else "",
                    "value": item.value if hasattr(item, 'value') else 0
                })

        # Use ResponseBuilder for auto-truncation
        return ResponseBuilder.success("data", items)

    except Exception as e:
        return format_error_response("data", e)