How to Use the New Relic AI (LLM Observability) MCP in Vercel AI SDK

Q: How do I monitor Vercel AI SDK costs with New Relic AI (LLM Observability)?

You hook the queryllmcosts tool into your SDK flow. It pulls usage data directly from your New Relic environment, letting you display spend per request in your dashboard.

Q: Can I track p95 latency for Vercel AI SDK using New Relic AI (LLM Observability)?

Yes. You trigger queryllmlatency to fetch performance snapshots for your specific models. It provides the hard numbers you need to detect bottlenecks before they impact users.

Q: Does New Relic AI (LLM Observability) handle Vercel AI SDK error logs?

It does. By using queryllmerrors, you can surface diagnostic data directly in your app. This helps you identify failing prompts or model timeouts instantly.

Track LLM costs and latency directly in your Vercel AI SDK frontend to keep your production apps performing and profitable.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect New Relic AI (LLM Observability) MCP to Vercel AI SDK

Create your Vinkius account to connect New Relic AI (LLM Observability) to Vercel AI SDK and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup New Relic AI (LLM Observability) with Vercel AI SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Real-time cost and latency tracking

Feed your UI live performance metrics by piping `query_llm_costs` and `query_llm_latency` into your stream. You get instant visibility into token usage and response times without blocking the user experience. This MCP Server connects your frontend to telemetry data so your users see exactly how models behave. It is built to keep your edge functions lean and your metrics transparent.

Audit model errors and feedback loops

Expose `query_llm_errors` and `query_llm_feedback` to capture what happens when models fail or receive negative user sentiment. You can map these events to UI components for immediate debugging. Your application logic stays responsive while the background tools gather the necessary diagnostic data. It removes the guesswork from debugging production LLM interactions.

Automated telemetry event logging

Use `post_custom_event` to push application-specific state changes back into your monitoring stack. It acts as a bridge between user actions and your observability backend. This keeps your event logs synced with user activity. You monitor the full lifecycle of a request from the initial prompt to the final feedback loop.

Setup guide

Set up New Relic AI (LLM Observability) MCP in Vercel AI SDK

Prerequisites

Node.js 18+ and a TypeScript project
ai + @modelcontextprotocol/sdk packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies

Run npm install ai @modelcontextprotocol/sdk plus your preferred model provider (e.g. @ai-sdk/openai).
2

Create the Streamable HTTP transport

Use StreamableHTTPClientTransport with your Vinkius endpoint URL. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Discover and use tools

Call mcpClient.tools() to auto-discover all New Relic AI (LLM Observability) tools. Pass them directly to generateText() or streamText() — no manual schema definitions needed.
4

Works with any model provider

Swap openai("gpt-4o") for any AI SDK provider — Anthropic, Google, Mistral. The MCP tools work identically across all supported models.

index.ts

import { experimental_createMCPClient as createMCPClient } from "ai";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp";
import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";

const transport = new StreamableHTTPClientTransport(
  new URL("https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
);

const mcpClient = await createMCPClient({ transport });
const tools = await mcpClient.tools();

const { text } = await generateText({
  model: openai("gpt-4o"),
  tools,
  prompt: "List recent New Relic AI (LLM Observability) transactions",
});

console.log(text);
await mcpClient.close();

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by New Relic AI. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect New Relic AI (LLM Observability) now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about New Relic AI (LLM Observability) MCP in Vercel AI SDK

You hook the `query_llm_costs` tool into your SDK flow. It pulls usage data directly from your New Relic environment, letting you display spend per request in your dashboard.

Yes. You trigger `query_llm_latency` to fetch performance snapshots for your specific models. It provides the hard numbers you need to detect bottlenecks before they impact users.

It does. By using `query_llm_errors`, you can surface diagnostic data directly in your app. This helps you identify failing prompts or model timeouts instantly.

This server only touches telemetry data like token counts, latency timestamps, and structured feedback records. It does not store raw user prompts or sensitive PII in the observability layer.

It is. The transport layer is designed for low-latency communication. It handles the handshake efficiently so you don't stall your request streams.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python