A comprehensive Model Context Protocol (MCP) server for Datadog integration, providing full CRUD access to Datadog APIs with modern async patterns. Built with the official Datadog Python SDK and MCP Python SDK.

• 🔧 Full CRUD operations - Create, read, update, delete across all supported APIs
• ⚡ Async operations - Built with AsyncApiClient for optimal performance
• 🔄 Automatic retries - Rate limiting and error handling with exponential backoff
• 📊 Comprehensive coverage - 31 tools across all major Datadog APIs
• 💾 Local caching - Results stored as timestamped JSON files
• 🔒 Type-safe - Full type hints and Pydantic models
• 📈 Built-in analysis - Statistical analysis, trend detection, and data summarization
• 🛡️ Security-first - Environment-based credential management

• Python 3.8+
• Valid Datadog API and Application keys
• MCP-compatible client (VS Code, Cursor, Claude Desktop, etc.)

# Install dependencies
pip install -r requirements.txt

# Set environment variables
export DATADOG_API_KEY="your_api_key"
export DATADOG_APP_KEY="your_app_key"
export DATADOG_SITE="datadoghq.com"  # Optional

# Run the server
python server.py

1. Install the Continue extension in VS Code
2. Add to your Continue config (~/.continue/config.json):

{
  "mcpServers": {
    "datadog": {
      "command": "python",
      "args": ["/path/to/datadog-mcp-python/server.py"],
      "env": {
        "DATADOG_API_KEY": "your_api_key",
        "DATADOG_APP_KEY": "your_app_key"
      }
    }
  }
}

1. Open Cursor settings
2. Add MCP server configuration:

{
  "mcp.servers": {
    "datadog": {
      "command": "python",
      "args": ["/path/to/datadog-mcp-python/server.py"],
      "env": {
        "DATADOG_API_KEY": "your_api_key",
        "DATADOG_APP_KEY": "your_app_key"
      }
    }
  }
}

1. Configure in your Q Developer settings:

{
  "mcpServers": {
    "datadog-mcp": {
      "command": "python3",
      "args": ["/path/to/datadog-mcp-python/server.py"],
      "env": {
        "DATADOG_API_KEY": "your_api_key",
        "DATADOG_APP_KEY": "your_app_key",
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "datadog": {
      "command": "python",
      "args": ["/path/to/datadog-mcp-python/server.py"],
      "env": {
        "DATADOG_API_KEY": "your_api_key",
        "DATADOG_APP_KEY": "your_app_key"
      }
    }
  }
}

1. Install Gemini CLI with MCP support
2. Configure the server:

gemini mcp add datadog python /path/to/datadog-mcp-python/server.py \
  --env DATADOG_API_KEY=your_api_key \
  --env DATADOG_APP_KEY=your_app_key

For any MCP-compatible client, use these connection details:

• Transport: stdio
• Command: python server.py
• Working Directory: /path/to/datadog-mcp-python/
• Environment Variables: DATADOG_API_KEY, DATADOG_APP_KEY

• validate_api_key - Test API credentials
• get_metrics - Query time series data
• search_metrics - Find metrics by pattern
• get_metric_metadata - Get metric metadata
• get_monitors - List monitoring alerts
• get_monitor - Get specific monitor details
• create_monitor - Create new monitoring alerts
• update_monitor - Update existing monitors
• delete_monitor - Delete monitors

• get_dashboards - List all dashboards
• get_dashboard - Get dashboard details
• create_dashboard - Create new dashboards
• update_dashboard - Update existing dashboards
• delete_dashboard - Delete dashboards

• search_logs - Search log entries
• get_events - Get system events

• get_infrastructure - Get host information
• get_service_map - Get service dependencies
• get_tags - Get host tags
• get_downtimes - Get scheduled downtimes
• create_downtime - Create scheduled downtimes

• get_synthetics_tests - Get synthetic tests
• get_rum_applications - Get RUM applications

• get_security_rules - Get security monitoring rules
• get_incidents - Get incident data (with pagination)
• get_slos - Get Service Level Objectives
• get_notebooks - Get Datadog notebooks

• get_teams - Get teams
• get_users - Get users

• analyze_data - Analyze cached data
• cleanup_cache - Clean old cache files

Once connected to an MCP client, you can use natural language to interact with Datadog:

• "Show me all monitors that are currently alerting"
• "Create a monitor for high CPU usage above 80%"
• "Get metrics for system.cpu.user over the last hour"
• "Search for all memory-related metrics"

• "List all my dashboards"
• "Create a new dashboard for system monitoring"
• "Show me the widgets in my main dashboard"

• "Show me all hosts and their status"
• "Get the service map for my application"
• "List all tags for production hosts"

• "Show me all active incidents"
• "Get the latest security monitoring rules"
• "List all SLOs and their current status"

The server uses the latest Datadog API client with:

• AsyncApiClient for non-blocking operations
• Automatic retry on rate limits (429 errors)
• 3 retry attempts with exponential backoff
• Unstable operations enabled for pagination

• DatadogMCPServer: Main server class with API client management
• DatadogConfig: Pydantic model for configuration validation
• Tool Handlers: Individual async functions for each API endpoint
• Data Storage: Automatic JSON file caching with timestamps
• Analysis Engine: Built-in data analysis capabilities

1. Request: MCP client calls tool with parameters
2. API Call: Server makes authenticated request to Datadog API
3. Storage: Response data is cached to local JSON file
4. Analysis: Optional built-in analysis of the data
5. Response: Summary and file path returned to client

• All API calls are asynchronous
• Non-blocking file I/O operations
• Efficient memory usage for large datasets

• Respects Datadog API rate limits
• Automatic retry logic with exponential backoff
• Efficient batching for bulk operations

# Create a monitor
create_monitor(
    name="High CPU Usage",
    monitor_type="metric alert", 
    query="avg(last_5m):avg:system.cpu.user{*} > 0.8",
    message="CPU usage is high @slack-alerts"
)

# Create a dashboard
create_dashboard(
    title="System Overview",
    layout_type="ordered",
    widgets=[{
        "definition": {
            "type": "timeseries",
            "requests": [{"q": "avg:system.cpu.user{*}"}]
        }
    }]
)

# Schedule downtime
create_downtime(
    scope=["host:web-server-01"],
    start=1640995200,
    end=1640998800,
    message="Scheduled maintenance"
)

• Full CRUD operations - Complete create, read, update, delete support
• Write operations enabled - All mutation tools available
• Local data caching - All results stored locally as JSON files
• Error handling - Comprehensive exception management
• Pagination support - Handle large datasets efficiently
• Type safety - Full type hints throughout
• Rate limiting - Automatic retry on API limits

# Install development dependencies
pip install -r requirements.txt
pip install pytest pytest-cov black flake8 mypy

# Format code
black server.py
flake8 server.py --max-line-length=88

# Run tests
cd tests && python -m pytest --cov=../server

1. Add new method to DatadogMCPServer class
2. Decorate with @self.mcp.tool()
3. Implement proper error handling and data storage
4. Add tests and update documentation

1. Authentication Error: Verify your DATADOG_API_KEY and DATADOG_APP_KEY are correct
2. Connection Issues: Ensure the server is running and accessible
3. Permission Errors: Check that your API keys have the necessary permissions
4. Rate Limiting: The server automatically handles rate limits with retries

Enable debug logging by setting:

export DATADOG_DEBUG=true

MIT License - see LICENSE file for details.