---
title: "Connect New Relic to ChatGPT: Manage Users, Dashboards, and Alerts"
slug: connect-new-relic-to-chatgpt-manage-users-dashboards-and-alerts
date: 2026-06-09
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect New Relic to ChatGPT using an MCP server. Automate NRQL dashboard creation, manage alert policies, and provision users with AI agents."
tldr: "Connect New Relic to ChatGPT using an auto-generated MCP server to manage dashboards, users, and alerts. This guide covers New Relic API quirks, handling rate limits, and building automated incident triage workflows."
canonical: https://truto.one/blog/connect-new-relic-to-chatgpt-manage-users-dashboards-and-alerts/
---

# Connect New Relic to ChatGPT: Manage Users, Dashboards, and Alerts


If you are an SRE, DevOps engineer, or IT admin, you likely spend hours jumping between New Relic dashboards, tweaking NRQL queries, and managing user access tiers. You want to connect New Relic to ChatGPT so your AI agents can read system states, update alert policies, and dynamically generate dashboards based on incident context. If your team relies on Claude instead, check out our guide on [connecting New Relic to Claude](https://truto.one/connect-new-relic-to-claude-control-monitoring-and-team-access/), or explore our broader architectural overview on [connecting New Relic to AI Agents](https://truto.one/connect-new-relic-to-ai-agents-automate-ops-and-infrastructure/).

Giving a Large Language Model (LLM) read and write access to a sprawling observability platform like New Relic is an engineering challenge. You either spend weeks building, hosting, and maintaining a custom [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) to translate JSON-RPC requests into New Relic API calls, or you use a [managed infrastructure layer](https://truto.one/how-to-architect-a-multi-tenant-mcp-server-for-enterprise-b2b-saas/) that handles the boilerplate for you.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for New Relic, [connect it natively to ChatGPT](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), and execute complex observability workflows using natural language.

## The Engineering Reality of the New Relic API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into REST API requests. While Anthropic's open standard provides a predictable way for models to discover tools, implementing it against vendor APIs is painful. If you decide to build a custom MCP server for New Relic, you are responsible for the entire API lifecycle.

Here are the specific integration challenges that break standard CRUD assumptions when working with New Relic:

### The GraphQL and REST Divide
New Relic is in the middle of a massive architectural transition. Much of their modern infrastructure (like querying telemetry data, managing tags, and handling advanced alerts) is powered by NerdGraph, their proprietary GraphQL API. However, many older operations and partner-level integrations still rely on their REST API v2. If you are building a custom MCP server, you have to write code that maps flat LLM function arguments into complex, nested GraphQL mutations for some tools, while formatting standard JSON payloads for others. A managed platform abstracts this away, exposing everything to the LLM as a flat, predictable JSON-RPC tool call.

### Strict Rate Limits and Standardized Headers
New Relic enforces strict rate limits based on concurrent queries, payload sizes, and minute-by-minute request counts. If an LLM attempts to paginate through 10,000 synthetic monitors in a tight loop, the API will reject the request with an HTTP `429 Too Many Requests` error. 

It is critical to understand how this is handled at the infrastructure layer: **Truto does not retry, throttle, or apply backoff on rate limit errors.** When New Relic returns an HTTP 429, Truto passes that error directly back to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller (your LLM framework, LangGraph agent, or ChatGPT instance) is entirely responsible for reading the `ratelimit-reset` timestamp and implementing its own retry or backoff logic.

### Base64 Entity GUIDs
Everything in New Relic is tied to an Entity GUID. These are not simple integers or UUIDs; they are massive, base64-encoded strings that encode the account ID, domain, and entity type. LLMs are notoriously bad at handling long, opaque strings. If the LLM truncates the GUID or attempts to decode it, the API calls will fail. Your MCP server must explicitly instruct the LLM via tool descriptions to pass these GUIDs back exactly as received.

## How to Generate a Managed MCP Server for New Relic

Instead of dealing with NerdGraph schema drift and building your own proxy, you can use Truto to dynamically generate a New Relic MCP server. Each server is scoped to a single authenticated New Relic account and exposes a curated list of tools derived directly from the API's documentation and schemas.

There are two ways to create this server.

### Method 1: Via the Truto UI

If you prefer a visual interface, you can generate the server directly from your dashboard:

1. Navigate to the **Integrated Accounts** page in the Truto UI and select your connected New Relic account.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Define your configuration (name, allowed methods, specific tags, and optional expiration date).
5. Click Save and copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

For teams building automated infrastructure or deploying AI agents programmatically, you can generate the MCP server via a REST endpoint. The API validates the New Relic connection, provisions a secure, hashed token in the key-value store, and returns the ready-to-use URL.

**Endpoint:** `POST /integrated-account/:id/mcp`

```typescript
// Example using fetch to create a read-only New Relic MCP server
const response = await fetch('https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "New Relic Triage Agent MCP",
    config: {
      methods: ["read"], // Restrict the LLM to get and list operations
      tags: ["monitoring", "users"]
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});

const mcpServer = await response.json();
console.log(mcpServer.url); 
// Output: https://api.truto.one/mcp/a1b2c3d4e5f6...
```

This URL is fully self-contained. It encodes the authentication token, the specific New Relic tenant routing, and the filtering rules you applied.

## Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, connecting it to ChatGPT takes less than a minute. You do not need to configure OAuth or handle JSON schemas manually; ChatGPT handles the MCP handshake, discovers the capabilities, and maps the tools automatically.

### Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable the **Developer mode** toggle (MCP support requires this flag).
3. Under **MCP servers / Custom connectors**, click add a new server.
4. Enter a Name (e.g., "New Relic Ops").
5. Paste the Truto MCP URL into the **Server URL** field.
6. Save the configuration. ChatGPT will immediately connect, perform the JSON-RPC initialization handshake, and list the available New Relic tools.

### Method B: Via Manual Config File

If you are running the Claude Desktop app, Cursor, or a local instance of an MCP client that relies on a JSON configuration file, you connect via Server-Sent Events (SSE) using the official MCP transport package.

Update your `mcp.json` or equivalent configuration file:

```json
{
  "mcpServers": {
    "new-relic-ops": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}
```

## Hero Tools for New Relic Automation

Truto derives MCP tools dynamically from the New Relic integration's available resources. When ChatGPT calls the `tools/list` endpoint, it receives the exact query and body schemas required to execute the API call. Here are the highest-leverage operations for observability workflows.

### Retrieve Dashboard Configuration
`get_single_new_relic_dashboard_by_id`

Retrieves the full JSON configuration of a specific dashboard, including its metadata, pages, widgets, and the underlying NRQL variables. This is critical when you want the AI to analyze what metrics are currently being tracked for a service.

> "Pull the configuration for the production web core dashboard using its GUID, and tell me which NRQL queries are driving the primary error rate widgets."

### Create a New Dashboard
`create_a_new_relic_dashboard`

Provisions a simple New Relic dashboard in a specific account using a single NRQL query. The LLM must formulate a valid NRQL string based on your prompt, select the target account ID, and provide a name. 

> "Create a new dashboard named 'Checkout Service Errors' in account 123456. Write a NRQL query that visualizes the count of HTTP 500 errors grouped by host over the last 24 hours."

### Audit Alert Policies
`list_all_new_relic_alert_policies`

Lists all alert policies configured for a New Relic account, including each policy's ID, name, and incident preference (e.g., PER_POLICY, PER_CONDITION). AI agents use this to audit monitoring coverage.

> "List all the alert policies in our primary APM account. Cross-reference their incident preferences and flag any policies that are set to PER_POLICY instead of PER_CONDITION."

### Review Synthetic Monitors
`list_all_new_relic_synthetic_monitors`

Retrieves all synthetic monitors (ping, API, browser, and scripted) visible to the authenticated user. This returns each monitor's GUID, type, and key configuration tags.

> "Check the status of our global synthetic monitors. Give me a breakdown of all API monitors targeting the billing service and let me know which regions they are testing from."

### List Provisioned Users
`list_all_new_relic_users`

Retrieves a list of all users available in the New Relic account. This is heavily used by IT teams running access audits or SOC2 compliance checks.

> "Get a list of all provisioned New Relic users. Filter the list to show only users assigned to the FULL_USER_TIER and format the output as a Markdown table."

### Provision a New User
`create_a_new_relic_user`

Creates a new user in a manually provisioned New Relic authentication domain. The agent provides the authentication domain ID, the user's email, display name, and the requested tier (BASIC_USER_TIER, CORE_USER_TIER, or FULL_USER_TIER).

> "Provision a new account for sarah.connors@company.com in our primary auth domain. Set her display name to Sarah Connors and assign her to the CORE_USER_TIER."

### Inspect Service Levels (SLIs/SLOs)
`list_all_new_relic_service_levels`

Retrieves the service level configuration for a specific entity. It returns the Service Level Indicators (SLIs), objective targets, and the rolling time window.

> "Fetch the current SLO targets for the checkout service entity. Tell me if the valid and good event NRQL clauses are tracking HTTP 200 responses accurately."

For the complete tool inventory and schema details, see the [New Relic integration page](https://truto.one/integrations/detail/newrelic).

## Workflows in Action

Connecting New Relic to ChatGPT moves your team away from manual point-and-click operations and toward intent-driven automation. Here are two concrete workflows an SRE can execute via the MCP server.

### Scenario 1: Automated Incident Triage & Dashboard Generation

During an outage, an on-call engineer needs immediate visibility into specific services without spending five minutes writing custom NRQL queries.

> **User Prompt:** "We are seeing elevated latency on the payment gateway. Find the alert policies related to the payment service, list the synthetic monitors currently testing it, and then create a new temporary dashboard that visualizes the transaction duration for the payment gateway over the last 60 minutes."

**Execution Steps:**
1. **`list_all_new_relic_alert_policies`**: The agent searches for policies matching "payment" to understand what thresholds are currently being breached.
2. **`list_all_new_relic_synthetic_monitors`**: The agent pulls the configuration of synthetic tests targeting the payment API to check if the failure is external or internal.
3. **`create_a_new_relic_dashboard`**: The agent formulates a NRQL query (e.g., `SELECT average(duration) FROM Transaction WHERE appName = 'PaymentGateway' SINCE 60 MINUTES AGO TIMESERIES`) and provisions a new dashboard.

**Result:** The engineer receives a comprehensive summary of the alert state, the status of external synthetic tests, and a direct link to a newly created dashboard visualizing the exact incident data.

### Scenario 2: Access Auditing & Developer Provisioning

IT administrators frequently receive Jira tickets requesting New Relic access. Instead of manually clicking through the New Relic UI to check seat availability and assign tiers, the admin delegates this to ChatGPT.

> **User Prompt:** "Check if j.smith@company.com already has a New Relic account. If not, provision them a BASIC_USER_TIER account in the engineering auth domain. Afterwards, give me a list of all FULL_USER_TIER accounts so I can audit our billing seats."

**Execution Steps:**
1. **`list_all_new_relic_users`**: The agent checks the directory for `j.smith@company.com`.
2. **`list_all_new_relic_authentication_domains`**: The agent retrieves the ID for the "engineering" auth domain.
3. **`create_a_new_relic_user`**: The agent sends the mutation to create the new basic user.
4. **`list_all_new_relic_users`**: The agent queries the directory again, filtering purely for `FULL_USER_TIER` accounts, and outputs the final list.

**Result:** The user is provisioned instantly, and the IT admin receives a markdown table of all premium tier users for immediate billing review.

## Security and Access Control

Exposing an enterprise observability platform to an LLM requires strict governance. Truto's MCP implementation allows you to lock down the server before it ever reaches ChatGPT:

* **Method Filtering:** Restrict the server to read-only operations. By setting `config.methods = ["read"]`, the LLM can only execute `get` and `list` requests. If it attempts to delete a dashboard or alter an alert policy, the MCP server rejects it at the protocol level.
* **Tag Filtering:** Group tools by functional area. By defining `config.tags = ["users"]`, you can create an IT-specific MCP server that only has access to user provisioning, completely isolated from application telemetry.
* **Short-Lived Expiration:** Use the `expires_at` field to generate temporary MCP servers. If a contractor needs access to New Relic data via ChatGPT to debug an issue, you can set the server to auto-expire at the end of the week. Cloudflare KV and durable alarms ensure the token is permanently destroyed.
* **Require API Token Auth:** For highly sensitive environments, possession of the MCP URL isn't enough. By enabling `require_api_token_auth`, the client must also provide a valid Truto API token in the Authorization header, adding a second layer of identity verification.

## Building Observability AI Agents

The mandate for AI in DevOps is no longer just log summarization; it is autonomous action. To achieve that, your AI agents need reliable, schema-aware access to the underlying vendor APIs.

You can spend your engineering sprints reading NerdGraph documentation, writing exponential backoff logic for 429s, and maintaining complex JSON-RPC routers. Or, you can rely on a managed infrastructure layer.

> Stop building custom API integrations for your AI agents. Use Truto's SuperAI to instantly generate managed MCP servers for New Relic and 100+ other enterprise SaaS platforms.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)