New Relic AI MCP: Real-Time LLM Observability & Cost Tracking

The Death of Dashboard Fatigue

Every DevOps engineer knows the ritual. A deployment goes live, and suddenly, your Slack is flooded with messages about slow responses or unexpected behavior. Your first instinct is to switch tabs, open your browser, navigate through a labyrinth of New Relic dashboards, and start digging through complex NRQL queries to find out what happened.

This context switching is the silent killer of developer productivity. When you are in the middle of an intense debugging session in Cursor or Claude Desktop, every second spent navigating a web UI is a second lost from your actual work. Even worse, traditional observability tools—while excellent at monitoring microservices—were not originally designed for the non-deterministic, high-cost nature of LLM interactions. You find yourself manually extracting data to see if a specific model upgrade caused a latency spike or if your token spend just hit a critical threshold.

The era of “view-undesirable” dashboards is ending. The next frontier of observability isn’t about having more charts; it’s about bringing the telemetry directly into your development workflow.

Making Observability Conversational

The New Relic AI MCP server changes the fundamental relationship between an engineer and their monitoring data. By leveraging the Model Context Protocol (MCP) through the Vinkius AI Gateway, you can turn your AI assistant into a real-time observability agent.

Instead of navigating menus, you simply ask. “What is my total LLM token cost for the last 24 hours?” or “Show me the p95 latency for GPT-4o.” Your AI client—whether it’s Claude Desktop, Cursor, VS Code, or Windsurf—becomes a powerful interface for your New Relic telemetry.

By connecting via Vinkius Edge, you gain access to all your New Relic data without ever needing to manage complex API keys or manual authentication within your IDE. You use your personal Connection Token from your Vinkius dashboard, and the infrastructure handles the routing, authentication, and protection of your sensitive telemetry.

Feature Deep Dive: Cost & Performance at Your Fingertips

The true power of this integration lies in its specialized toolset, designed specifically to address the “blind spots” in AI operations.

Conversational Token Auditing

One of the most pressing challenges in LLM deployment is the lack of visibility into real-time spend. The query_llm_costs tool allows you to perform structural extraction of model costs directly through your agent.

You can ask questions like: “How much did Claude 3.5 Sonnet cost me yesterday?”

The agent will execute a NRQL aggregation, summing the tokenSpanCost property from your LLM events and providing a clear financial breakdown. No more manual spreadsheet tracking or hunting through billing logs; you get an instant, natural language summary of your model spend across your entire AI infrastructure.

Real-time Latency Monitoring

Latency regressions in LLM text generation can be devastating to user experience. The query_llm_latency tool provides the precise metrics needed to catch these issues before they impact your users.

By querying for p95 latency matrices, you can identify exactly when a model’s response time begins to drift. If you notice a spike in duration, you can immediately follow up by asking the agent to investigate specific error types or even run custom queries to see if the issue is isolated to a particular region or provider.

Deep Telemetry Interface

For engineers who need more than just high-level summaries, the custom_nrql tool provides an unrestricted window into your data. If you have a complex question that isn’t covered by a pre-built tool, you can provide any valid, read-only NRQL string directly to your agent.

This allows for deep interrogation of the LlmEvent and LLMChatCompletionMessage datasets. You can query for specific prompt inputs, analyze token distribution patterns, or even track custom behavioral markers using the post_custom_event tool. It bridges the gap between raw telemetry and actionable, agentic insights.

The Vinkius Advantage: Security and Simplicity

Connecting to New Relic via a traditional method often involves managing sensitive API keys across multiple environments and clients. This creates a massive security surface area.

Vinkius simplifies this through the Vinkius Edge layer. When you use an App Connector on Vinkius, you are using a managed proxy that handles all MCP connections. Your New Relic credentials stay encrypted and isolated; your AI client only ever sees the Vinkius Edge URL and your personal Connection Token.

Furthermore, every connection is protected by the Security Passport. You can see exactly what permissions each server uses—whether it’s network access or data retrieval—ensuring that you remain in full control of your observability stack. This is combined with the Guardian Control Plane, which gives you a real-time feed of every tool execution, providing complete transparency into what your AI agents are doing with your telemetry.

Conclusion: Building a Proactive AI Stack

The transition from reactive monitoring to proactive, agent-driven observability is a necessity for anyone building in the AI era. We can no longer afford to be tethered to browser-based dashboards that require constant context switching and manual data extraction.

By integrating New Relic AI directly into your development environment via MCP, you transform your AI assistant from a simple code generator into a sophisticated, telemetry-aware partner. You move from asking “What happened?” after a failure to knowing exactly how your models are performing, how much they cost, and where the latency bottlenecks lie—all through a single, conversational interface.

Find the New Relic AI MCP server in the App Catalog and start making your observability as intelligent as your models.