New Relic MCP tool reference

New Relic's MCP server provides specialized tools that enable AI agents to access and analyze your observability data. This reference guide organizes all available tools by category.

How to use MCP tools

MCP tools are invoked through natural language queries in your AI development environment. You don't need to memorize exact tool names or parameters. Just describe what you want to know about your New Relic data.

Example queries:

• "What entities are in my account?"
• "Show me recent alerts for my web application"
• "What are the top errors from the last hour?"
• "Run an NRQL query to analyze performance"

The AI agent in your development tool will automatically select the appropriate MCP tools and format the results for you.

Filter tools with include-tags

Some tools appear in multiple categories (for example, analyze_deployment_impact is relevant to both incident-response and advanced-analysis) because they are tagged with multiple relevant tags.

You can dynamically filter the tools your supported MCP client receives by sending the include-tags HTTP header with your requests. This allows you to request only specific subsets of tools, which is helpful for reducing the tool corpus and helping to improve the efficiency and accuracy of whatever AI model is being used for the inquiry.

The available tags you can use for filtering correspond directly to the category headers in this reference: discovery, data-access, alerting, incident-response, performance-analytics, as well as advanced-analysis.

Example implementation

"servers": {
    "new-relic-mcp-server": {
        "url": "https://mcp.newrelic.com/mcp/",
        "type": "http",
        "headers": {
            "include-tags": "discovery,alerting"
        }
    }
}

In this example, the AI agent will only be presented with tools categorized under discovery (for example, get_entity) and alerting (for example, list_alert_policies), ensuring that the model focuses only on the most relevant functions for its current task.

Entity and account management (tag: discovery)

• convert_time_period_to_epoch_ms: Convert a time period (for example, "last 30 minutes") to epoch milliseconds.
• get_dashboard: Fetch details about a specific dashboard.
• get_entity: Fetch New Relic entities by GUID or search by name pattern.
• list_related_entities: List entities 1 hop away (related) from a given entity GUID.
• list_available_new_relic_accounts: List all account IDs available to the user.
• list_dashboards: List all dashboards for a New Relic account.
• search_entity_with_tag: Search for entities using a specific tag key and value.
• list_metric_names: Discover all available metric names (dimensional and legacy timeslice) reported by an entity or account.

Data Access (tag: data-access)

• execute_nrql_query: Execute an NRQL query against NRDB.
• natural_language_to_nrql_query: Execute a query by converting a natural language request into an NRQL query, executing it, and returning the results.

Alerts and monitoring (tag: alerting)

• list_alert_conditions: List alert condition details for a specific alert policy.
• search_incident: List all alert events (both open and close events) with flexible filtering.
• list_alert_policies: List alert policies for the specified account, optionally filtering by policy name.
• list_recent_issues: Lists all open issues in New Relic for the specified account.
• list_synthetic_monitors: List all synthetic monitors (automated tests that check your services' availability and performance).
• list_synthetic_monitor_results: Return individual synthetic check run rows (timings, errors, locations) for a monitor over a time window.
• get_synthetic_check_statistics: Aggregate synthetic check success rates, failure counts, and duration percentiles across monitors or locations.

Alert event response (tag: incident-response)

• analyze_deployment_impact: Analyze the performance impact of a deployment on a specific entity.
• generate_alert_insights_report: Generate an alert intelligence analysis report for a specific issue.
• generate_user_impact_report: Generate an end-user impact analysis report for a specific issue.
• list_entity_error_groups: Fetch error groups for a specific entity from the Errors Inbox within a time window.
• list_change_events: List a history of change events from New Relic for the application identified by its entity GUID.
• get_error_statistics: Compute aggregate error counts, first/last seen timestamps, and optional time-series trends from TransactionError events, with flexible filtering and faceting by error class, message, app, HTTP status, and more.
• search_errors: Return raw error events matching filters like message, class, HTTP status, or trace ID.

Performance analytics (tag: performance-analytics)

• analyze_entity_logs: Analyze application logs to identify error patterns, anomalous behavior, and recurring issues.
• analyze_golden_metrics: Analyze golden metrics (key health indicators: throughput, response time, error rate, and saturation).
• analyze_kafka_metrics: Analyze Kafka metrics including consumer lag, producer throughput, message latency, and partition balance.
• analyze_threads: Analyze thread metric data for a given entity including thread state, CPU usage, and memory consumption.
• analyze_transactions: Analyze transactions for a specific entity within a time window, identifying slow and error-prone transactions, including P95 and P99 latency metrics (the response time thresholds for the slowest 5% and 1% of requests).
• list_garbage_collection_metrics: List garbage collection and memory metrics for a given account and entity.
• list_recent_logs: List recent logs from New Relic for the specified account and entity GUID.
• list_entity_performance_risk_groups: Fetch performance risks groups for a specific entity from the Performance Risks Inbox within a time window.
• get_metric_statistics: Fetch aggregated metric values (average, sum, percentiles, rate) for a given dimensional or timeslice metric.
• get_log_statistics: Return aggregate log counts, breakdowns by level and attribute, and trends over a time window.
• get_distributed_trace_details: Returns full span attributes, anomalies, and span links for a specific entity or individual span within a trace.

Advanced analysis (tag: advanced-analysis)

• analyze_deployment_impact: Analyze the performance impact of a deployment on a specific entity.
• generate_alert_insights_report: Generate an alert intelligence analysis report for a specific issue.
• generate_user_impact_report: Generate an end-user impact analysis report for a specific issue.
• natural_language_to_nrql_query: Convert a natural language request into an NRQL query, execute it, and return results.

Skills

Skills are pre-built workflows that combine multiple MCP tools to help you investigate and resolve common observability scenarios. Skills are hosted in the New Relic skills hub repository.

Customers can download these skills and configure them according to their specific AI agent.

Available skills:

OAuth-only tools

The following tools require OAuth authentication and are not available when using an API key.

AI-powered analysis tools: These tools are metered as Advanced Compute Capacity Units (aCCUs).

• natural_language_to_nrql_query
• generate_alert_insights_report
• generate_user_impact_report
• analyze_deployment_impact

Preview tools: See Preview tools. These also require OAuth.

Preview tools

The following tools are available at GA as preview features. They are read-only and provided for evaluation. Pricing will be determined after GA.

• search_traces: Search for the traces of a specific entity within a time window, ranked by duration, error count, or backend time.
• analyze_trace_anomaly: Analyze traces of a specific entity to identify the transaction or error class responsible for slow, failing, or high-volume traces.
• analyze_service_dependencies: Analyze a specific entity's service dependencies, mapping upstream and downstream connections and flagging which ones are unhealthy.