Highlight MCP. Ingest logs and traces to monitor user flow
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Highlight (Session Replay & UX) MCP Server. This server lets your AI agent manage observability data by ingesting raw logs, structured OTLP logs, and OTLP traces directly into Highlight.
Use it to monitor user experience, debug performance bottlenecks, and correlate backend service activity with actual user sessions via natural conversation.
What your AI agents can do
Ingest otlp logs
Sends structured OTLP JSON logs into Highlight.
Ingest otlp traces
Sends OTLP JSON traces into Highlight.
Ingest raw log
Sends a raw text log message into Highlight.
The agent sends simple, text-only log messages to your Highlight project for immediate visibility.
The agent sends logs formatted in OTLP JSON, preserving rich context and metadata for better analysis.
The agent sends OTLP traces, allowing you to visualize and track the entire performance path of a single request across multiple services.
The agent links service-side logs and traces to the user's session context within Highlight.
You use your AI client to automatically dump logs and traces when an error is detected, without manual copying and pasting.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Highlight (Session Replay & UX) MCP Server: 3 Tools for Observability
These tools allow your agent to send raw logs, structured OTLP logs, and OTLP traces directly into Highlight for deep performance and user experience monitoring.
019e5d23ingest otlp logs
Sends structured OTLP JSON logs into Highlight.
019e5d23ingest otlp traces
Sends OTLP JSON traces into Highlight.
019e5d23ingest raw log
Sends a raw text log message into Highlight.
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 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ 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
What you can do with this MCP connector
This MCP Server lets your AI agent manage all your observability data—logs, traces, and session replays—by feeding it right into Highlight. You'll use it to check user experience, debug slow spots, and connect what's happening on the backend to what the user actually saw, all through natural conversation. You don't gotta manually copy and paste a damn thing.
How Highlight MCP Works
- 1 Subscribe to the server and provide your Highlight Project ID.
- 2 Your AI agent executes one of the three tools (e.g.,
ingest_otlp_traces) with the relevant data payload. - 3 The data flows directly into your Highlight project, where it's ready for analysis alongside user session recordings.
The bottom line is, your agent handles the data plumbing, taking logs and traces from your code and dumping them straight into your observability dashboard.
Who Is Highlight MCP For?
This is for the Ops Engineer who needs to stop clicking through dashboards at 2 AM. It's for the Developer who hates copying stack traces. And for the Product Manager who needs to prove a UX flaw is due to a backend service failure—all using one chat prompt.
Automates the ingestion of structured OTLP data, ensuring system visibility and reducing manual setup time for new services.
Quickly sends local logs and traces to Highlight to debug issues without stopping their coding flow or leaving the terminal.
Correlates backend service logs with user session recordings to understand exactly where and why users get stuck.
What Changes When You Connect
- See full request paths by calling
ingest_otlp_traces. You don't have to manually track request IDs across five different microservices to find the bottleneck. - Debugging gets faster. Instead of copy-pasting stack traces into a ticket, just tell your agent to use
ingest_raw_logand dump the log directly to Highlight. - Keep data structured. Use
ingest_otlp_logsfor logs that have metadata. This means the AI client preserves rich context, letting you filter on resource IDs or service names immediately. - Correlate everything. You link backend failures (via the tools) to front-end user behavior (via session replay). You finally know if the user is stuck because of a slow service or bad UI design.
- Stop context switching. Your agent handles the entire data pipeline—from code execution to the observability platform—all from the chat interface.
Real-World Use Cases
A User Reports a Mystery Error
A PM receives a bug report. They prompt their agent: 'Check the user session ID 123 and find the backend error.' The agent runs ingest_otlp_traces with the relevant service spans. The PM immediately sees the performance bottleneck and the failing service in Highlight, solving the issue without waiting for the backend team.
Debugging a New API Endpoint
A developer writes a new API endpoint locally. Instead of running docker logs and copying the output, they use the agent to run ingest_raw_log with the output. The logs appear instantly in Highlight, letting them debug the service in the same place they wrote the code.
Improving Data Quality for Compliance
A DevOps team needs to prove data integrity. They use the agent to send highly structured logs via ingest_otlp_logs, ensuring that every log entry carries necessary metadata (like resource IDs). This meets strict compliance needs and makes data querying reliable.
Identifying Performance Drift
The team notices latency spikes on a critical feature. They ask the agent to capture traces for the last hour using ingest_otlp_traces. The resulting data in Highlight pinpoints the exact function call that is slowing down the user experience, allowing them to optimize the code.
The Tradeoffs
Manual Log Dumping
Running kubectl logs -f <pod-name> and manually copying blocks of text into a Jira ticket or Slack thread for review.
→
Use the agent to execute ingest_raw_log with the log output. This sends the data directly and reliably to Highlight, keeping your communication thread clean and the data searchable.
Ignoring Data Structure
Sending complex logs as plain text, losing crucial context like service name, resource ID, or severity level.
→
Always use ingest_otlp_logs. This sends logs in OTLP JSON, ensuring that the metadata is preserved and searchable within Highlight.
Treating Logs as Separate Items
Looking at a raw log entry, then having to switch tabs to look at the corresponding trace data to understand the request flow.
→
Use the agent to send both ingest_otlp_logs and ingest_otlp_traces. This co-locates the service log data and the performance data, allowing for immediate cross-referencing in Highlight.
When It Fits, When It Doesn't
Use this server if your primary need is observability correlation: linking a user's front-end experience (session replay) to specific, technical backend failures (logs/traces). You need to know why the user got stuck. Don't use this if you simply need to store logs—use a basic log storage service. Don't use this if you only need to monitor metrics (e.g., CPU utilization)—use a dedicated metrics tool. This server is for connecting the dots between the three: user, service, and data.
If you have raw text dumps, use ingest_raw_log.
If you have structured, contextual logs, use ingest_otlp_logs.
If you have distributed request flows, use ingest_otlp_traces.
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
Works with 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 server provides 3 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Finding the root cause of a bug shouldn't require switching five tabs.
Today, when a user reports an issue, you're stuck in a cycle of copy-pasting. You jump from the user dashboard to the logging service, find a stack trace, copy it, paste it into a ticket, and then switch to the tracing tool to try and find the corresponding request ID. It's a manual, brittle process that loses context every time you copy-paste.
With this MCP server, your agent handles the whole flow. You tell it what to find, and it runs the tools—`ingest_raw_log`, `ingest_otlp_logs`, and `ingest_otlp_traces`—sending all the necessary data directly to Highlight. You get a single, correlated view of the failure, no copy-pasting required.
Highlight (Session Replay & UX) MCP Server: Get structured logs and traces instantly
Before, dumping data meant choosing the right tool—was it a raw dump or a structured payload? You had to remember the difference and manually manage the payload format. If you missed the structure, the context was lost, and the data was useless for root cause analysis.
Now, your agent handles the complexity. You specify the data type, and the server uses the appropriate tool (`ingest_otlp_logs` or `ingest_otlp_traces`) to ensure the data lands correctly and is immediately actionable in Highlight.
Common Questions About Highlight MCP
How do I use the `ingest_raw_log` tool? +
You pass a simple string to the tool. This is best for quick debugging when you just have a stack trace or a simple service message. The data lands in Highlight for you to review.
What's the difference between `ingest_otlp_logs` and `ingest_raw_log`? +
The difference is structure. ingest_otlp_logs accepts OTLP JSON, preserving rich metadata (like resource IDs). ingest_raw_log is for simple text dumps and doesn't carry that structured context.
Can I send multiple types of data at once? +
Yes. You can chain calls to the three tools (ingest_otlp_logs, ingest_otlp_traces, and ingest_raw_log) using your agent to build a complete picture of a failure.
Does this server only work with OTLP data? +
No. While it supports OTLP for structured logs and traces, it also includes ingest_raw_log for simple, unstructured text messages.
How do I make sure my data is processed correctly when using `ingest_otlp_logs`? +
The payload must include the highlight.project_id attribute. This ID tells Highlight exactly where to place the structured logs you're sending.
What happens if I use `ingest_otlp_traces` with invalid OTLP JSON? +
The server rejects the payload and returns a detailed error message. You need to correct the JSON structure and resend the traces.
Can `ingest_raw_log` handle complex log formats like JSON? +
No, ingest_raw_log handles plain text strings only. If you have structured JSON, you should use ingest_otlp_logs instead.
Is there a limit on how many logs I can send using `ingest_otlp_logs`? +
The server has a rate limit of 1,000 payloads per minute. If you exceed this, your AI client will receive a 429 rate limit error.
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Vercel Alternative
Manage Vercel deployments, projects and domains via API — inspect builds, track deployments, manage env vars and domains from any AI agent.
Veracode
Bring Veracode AppSec to your AI. Analyze source code flaws, extract application profiles, and track vulnerabilities conversationaly.
RubyGems
Manage Ruby packages directly from your AI agent — search for gems, inspect versions, and track download statistics on RubyGems.org.
You might also like
Grafana
Manage observability via Grafana — search and inspect dashboards, monitor alerts, and handle data sources directly from any AI agent.
Hugging Face Vision
Connect Hugging Face Vision to any AI agent via MCP.
TopOn / Mobvista
Ad mediation and monetization platform for mobile games — monitor revenue, manage waterfalls, and optimize eCPM via AI.