Highlight MCP for AI. Monitor user flow and debug performance metrics.
Works with every AI agent you already use
…and any MCP-compatible client








How this MCP server connects to your AI agent
Highlight MCP sends raw text logs, structured OTLP JSON logs, and detailed traces directly into your Highlight dashboard. Use this MCP to centralize all observability data—from backend service activity to user interaction paths—for deep performance monitoring.
What AI agents can do with Highlight (Session Replay & UX) Automation
Ingest otlp logs
This sends structured OTLP JSON logs into Highlight for deep context and metadata tracking.
Ingest otlp traces
Use this to send full OTLP JSON traces, allowing you to visualize complete request paths.
Ingest raw log
This sends simple, unformatted text log messages directly into Highlight.
You can send simple, unstructured text logs from your backend services to Highlight.
The MCP accepts and processes complex, structured logs formatted in the OpenTelemetry Protocol (OTLP) JSON standard.
You can send full OTLP traces to visualize entire request flows and pinpoint exactly where latency occurs.
The data lands in Highlight, allowing you to tie backend failures back to specific monitored user experiences.
Ask an AI about this
Waiting for input…
What AI agents can do with Highlight (Session Replay & UX) with 3 Tools
These tools allow you to send raw text messages, structured OTLP logs, and detailed traces directly to Highlight for monitoring.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Highlight (Session Replay & UX) on VinkiusIngest Otlp Logs
This sends structured OTLP JSON logs into Highlight for deep context and metadata tracking.
Ingest Otlp Traces
Use this to send full OTLP JSON traces, allowing you to visualize complete request...
Ingest Raw Log
This sends simple, unformatted text log messages directly into Highlight.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Highlight (Session Replay & UX), then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Highlight. 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.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Built on the Model Context Protocol (MCP) for Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 3 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Finding the root cause of an outage used to mean jumping through hoops.
Today, when something breaks, you find one log snippet in the terminal, then copy a trace ID into your dashboard, and finally switch tabs to look at user behavior. It’s manual, it's slow, and you always feel like you missed some critical piece of context that only lives somewhere else.
With this MCP, everything lands together. Your agent routes raw logs, structured JSON data, and performance traces into one place in Highlight. You stop searching across tabs; you just start reading the single source of truth.
Ingesting all signals with Highlight's tools.
You no longer have to manually write scripts or build custom pipelines every time a new data source comes online. You just tell your AI client to use the MCP and send the data, letting it handle which tool—`ingest_otlp_logs`, `ingest_otlp_traces`, or `ingest_raw_log`—is needed.
The difference is that you get total signal coverage. You don't just see *that* something broke; you see the full, multi-layered story of how and why it broke.
What your AI can actually do with this
Need to figure out why a feature is slow or why an error popped up? This MCP lets you feed complex system signals—raw text, structured JSON logs, and full request traces—right into your Highlight project. You don't have to jump between five different dashboards just to correlate a user session with the backend failure.
Instead, your agent manages all that data ingestion for you.
The process is straightforward: send the data using natural conversation, and it lands in Highlight. Whether you’re debugging a specific API call or trying to understand general system health, this MCP gives your AI client access to every signal type needed. When you find observability tools on Vinkius, this one handles the messiest part—getting all the varied logs into a single source of truth for root cause analysis.
019e5d23-7122-703d-a3e4-a7ddb532a4e0 Here's how it actually works
The bottom line is that you send three different kinds of signals—text, structured JSON, and traces—and they all appear together in one place.
First, subscribe to this MCP and provide your unique Highlight Project ID.
Next, tell your agent or development environment which type of data you're sending (raw log, OTLP log, or trace).
The system ingests the payload, making it immediately viewable for analysis inside your Highlight dashboard.
Who is this actually for?
This MCP is for the SRE who gets tired of clicking through five different dashboards at 2 a.m. to find out why an endpoint failed. It's also perfect for developers and product managers who need to connect vague user complaints to hard, technical evidence.
Automates the ingestion of structured OTLP data across services so they can monitor system visibility without manual scripting.
Sends raw logs from local environments directly to Highlight to quickly debug issues against a live monitoring dashboard.
Connects backend performance data and error logs to user session reports, helping identify UX friction points that cause drop-offs.
What Changes When You Connect
You capture the messy context. By using ingest_raw_log, you ensure that simple, unstructured messages—like unique stack traces or session IDs—don't get dropped just because they aren't JSON-formatted.
Pinpoint latency with precision. Sending OTLP traces via ingest_otlp_traces lets you map out the exact sequence of function calls and identify which microservice is causing a bottleneck.
Maintain structured context. Use ingest_otlp_logs to ingest rich, standardized JSON data. This makes querying easier because all your metadata stays organized and searchable.
Connect the dots for product teams. You can correlate general user session behavior with specific backend failures by feeding logs into Highlight.
Speed up debugging cycles. Instead of manually pulling log snippets from ten different services, you send them all here to get a unified view.
See it in action
The checkout process fails intermittently
A Product Manager notices high drop-off rates during payment. They ask their agent to use the MCP to send ingest_otlp_traces and ingest_raw_log. The resulting data shows that a specific third-party payment API call is failing sporadically, leading to session loss.
System performance degrades at peak hours
An SRE suspects database contention. They use the MCP with ingest_otlp_logs and ingest_raw_log. The structured logs show a sudden spike in connection pool usage, while the raw logs point to specific slow query IDs that need tuning.
Debugging an obscure API error
A backend developer encounters a unique runtime exception. They use ingest_raw_log with the exact stack trace and service name, instantly making it visible in Highlight for review, eliminating hours of manual log searching.
Analyzing user flow across services
A team wants to see how a full user journey impacts performance. They use ingest_otlp_traces to map the entire call graph from the frontend through three separate microservices, identifying which handoff is adding unnecessary delay.
The honest tradeoffs
Only sending raw logs
The developer sends everything using ingest_raw_log because it's easy. But then, when they need to filter by a specific service name or error code, the data is just unparsed text and useless.
Use a combination approach. Send structured metadata with ingest_otlp_logs, but also send key context details using ingest_raw_log for maximum fidelity.
Only focusing on OTLP traces
The team tracks performance beautifully, seeing the path of a request. But they miss critical business logic failures—like an invalid user input that causes a graceful failure but isn't tracked as an error code.
Always pair trace data with ingest_raw_log. This captures those non-error state context messages that explain why the path was taken.
Ignoring structured logs entirely
The system fails, but since no one used ingest_otlp_logs, the team can only see a vague error message. They have zero context about which resource or module caused the failure.
Make it a habit to pipe all relevant structured data through ingest_otlp_logs first; this keeps your metadata clean and queryable.
When It Fits, When It Doesn't
Use this MCP if you need absolute, high-fidelity observability. Specifically, use it when the problem isn't just 'is the service up?' but rather, 'why is the service doing X slowly, and what was the user context that triggered it?'. You must ingest multiple signals: ingest_otlp_traces for performance mapping, ingest_otlp_logs for standardized metadata, and crucially, ingest_raw_log to capture any crucial but messy context. Don't use this if your only need is simple uptime monitoring; in that case, a dedicated metrics-only tool will be enough. This MCP is for deep failure analysis.
Questions you might have
How does ingest_raw_log differ from ingest_otlp_logs in Highlight? +
It's about structure. ingest_raw_log handles plain text, which is great for debugging stack traces or simple messages. However, ingest_otlp_logs forces a structured JSON format, making the data searchable and filterable by resource type.
Do I need all three tools to monitor performance? +
Yeah, you should. While OTLP traces (ingest_otlp_traces) show the path of a request, raw logs are often where the specific failure message lives, and structured logs (ingest_otlp_logs) provide the metadata needed to find that failure across thousands of records.
Can I use this MCP for non-API logging? +
Yep. If you're capturing user behavior or console messages that don't come from a standard API endpoint, you can still funnel them using ingest_raw_log to keep the context visible in Highlight.
Is ingest_otlp_traces only for microservices? +
Nah. While it's built for complex service calls, you can use it anytime you want to map a sequence of actions—even within a single application process—to track performance.
What specific parameters do I need to provide when using ingest_otlp_logs? +
You must include the highlight.project_id in the payload. This attribute tells your agent exactly which project within Highlight should receive the structured OTLP logs.
If I use ingest_raw_log, how do I handle sensitive user data? +
You are responsible for sanitizing any PII before calling this tool. While you can send raw text, always scrub names, emails, or IDs first to maintain privacy and security.
If I run ingest_otlp_traces many times in a row, is there a rate limit? +
The system handles large data volumes, but rapid-fire calls may hit API limits. It's best practice to batch your trace payloads or implement a small delay between ingestion runs.
What happens if the JSON I pass to ingest_otlp_logs is malformed? +
The agent will return an error message detailing the schema failure. It won't process incomplete data, requiring you to fix your payload before making a successful call.
How can I send a basic text log message to my dashboard? +
You can use the ingest_raw_log tool. Simply provide the service name and the message content, and it will be sent directly to Highlight.
Does this server support structured OpenTelemetry logs? +
Yes! Use the ingest_otlp_logs tool to send structured logs in OTLP JSON format. Ensure your payload includes the project ID attribute.
Can I visualize request traces using this integration? +
Absolutely. The ingest_otlp_traces tool allows you to send OTLP JSON traces to Highlight, helping you track request spans and performance.
We've already built the connector for Highlight. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 3 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.