otel-mcp
Provides tools for querying and analyzing OpenTelemetry traces, allowing AI agents to list recent traces, get span trees, search spans, and get service summaries.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@otel-mcp show me recent traces with errors"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
otel-mcp
MCP server that gives AI agents access to your application's OpenTelemetry traces.
Agent calls: list_traces { has_errors: true }
Recent Traces (2 of 847)
TRACE ID SERVICE DURATION SPANS ERRORS ROOT
a]b7f2e9d4c8 checkout-api 2.34s 12 1 POST /checkout
f3e1a8b2c6d9 checkout-api 1.87s 8 1 POST /checkout
Agent calls: get_trace { trace_id: "a]b7f2e9d4c8" }
Trace ab7f2e9d4c8
Services: checkout-api, inventory-service, postgres
Duration: 2.34s
Spans: 12, 1 error
SPAN TREE
----------------------------------------------------------------
[2.34s] POST /checkout
[1.92s] OrderService.create
[1.87s] InventoryService.reserve ← HTTP 500
[45ms] POST inventory-service/reserve
[23ms] pg.query SELECT * FROM products...
[412ms] PaymentService.charge
[401ms] stripe.charges.createThe agent can query traces, find errors, identify slow operations - without you copying logs into chat.
Why This Exists
AI agents can read code, but they can't see how it executes. When debugging locally, you end up checking traces yourself and explaining what you found. That's the bottleneck.
otel-mcp removes that step by letting agents query execution data directly.
Read more:
How to Give AI Agents Access to Runtime Traces — practical guide
Why AI Development Tools Must Be Execution-Aware — the design principle
Related MCP server: trazabilidad-mcp
Architecture
flowchart LR
subgraph app["Your Application"]
OTel["OpenTelemetry SDK"]
end
subgraph otel-mcp
Receiver["OTLP Receiver\n/v1/traces"]
Store[("Trace Store\n(in-memory)")]
MCP["MCP Server\n(stdio)"]
HTTP["HTTP API\n/mcp/*"]
end
subgraph client["Client Mode"]
MCP2["MCP Server\n(stdio)"]
end
Agent["AI Agent\n(Claude, Cursor)"]
OTel -->|"OTLP/HTTP\n:4318"| Receiver
Receiver --> Store
Store --> MCP
Store --> HTTP
MCP <-->|"MCP protocol"| Agent
HTTP <-->|"HTTP proxy"| MCP2
MCP2 <-->|"MCP protocol"| AgentPrimary mode: First instance runs the OTLP receiver and MCP server. Traces are stored in memory with LRU eviction.
Client mode: Additional instances detect the primary via health check and proxy MCP tool calls over HTTP. Multiple AI agents can share the same trace data.
Quick Start
Prerequisites: Node.js 18+
1. Add to your MCP client
Go to Cursor Settings → MCP → Add new global MCP server and paste:
{
"mcpServers": {
"otel": { "command": "npx", "args": ["otel-mcp"] }
}
}Or add to ~/.cursor/mcp.json directly.
claude mcp add otel -- npx otel-mcpAdd to your MCP config:
{
"mcpServers": {
"otel": { "command": "npx", "args": ["otel-mcp"] }
}
}2. Try it out
Run the example app to generate test traces:
# Clone and run example
git clone https://github.com/moondef/otel-mcp.git
cd otel-mcp/examples/node-app
npm install && npm startThen ask your AI agent: "Show me recent traces" or "Are there any errors?"
3. Instrument your app
Point your OpenTelemetry exporter at http://localhost:4318/v1/traces:
import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
const sdk = new NodeSDK({
traceExporter: new OTLPTraceExporter({
url: 'http://localhost:4318/v1/traces',
}),
instrumentations: [getNodeAutoInstrumentations()],
});
sdk.start();from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
exporter = OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")OpenTelemetry is a standard for collecting traces from applications. A trace shows the path of a request through your system - which functions ran, how long each took, what failed.
Getting started: Node.js · Python · Go · Java
Tools
Tool | Description |
| List recent traces. Filter by |
| Get span tree for a trace ID (prefix match supported). |
| Search spans with |
| Service overview with trace counts and recent errors. |
| Clear all collected traces. |
Multiple sessions
Multiple MCP clients share the same traces. First instance runs the collector on port 4318, others connect to it. Filter by service to focus on specific apps.
Configuration
Variable | Default | Description |
| 4318 | Collector port |
| 1000 | Max traces to retain |
| 10000 | Max spans to retain |
License
MIT
Available Tools
5 toolsclear_tracesClear TracesA
Clear all collected traces from memory. Useful for starting fresh between test runs or debugging sessions. Returns count of cleared traces.
Inputs: no named parameters.
get_summaryGet SummaryARead-only
Get an overview of all collected trace data. Shows total traces and spans, list of services, and recent errors. Good starting point to understand what data is available.
Inputs: no named parameters.
get_traceGet Trace DetailsARead-only
Get the detailed span tree for a specific trace. Shows the hierarchy of operations, their timing, and optionally their attributes. Use this to understand the full request flow and identify where time is spent.
Inputs: trace_id (required), show_attributes.
list_tracesList TracesARead-only
List recent traces from the application. Use this to get an overview of recent requests, find errors, or identify slow operations. Returns a table of traces with their duration, span count, and error count.
Inputs: service, has_errors, min_duration_ms, since_minutes, +2 more.
query_spansQuery SpansARead-only
Search for specific spans across all traces. Use this to find patterns like slow database queries, failed HTTP calls, or specific operations by name. More targeted than list_traces when looking for specific operation types.
Inputs: name, service, min_duration_ms, has_error, +4 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Each tool has a distinct purpose: clearing traces, getting summary, retrieving a specific trace, listing traces, and searching spans. No overlap or ambiguity.
All tool names follow a consistent verb_noun pattern in snake_case: clear_traces, get_summary, get_trace, list_traces, query_spans.
With 5 tools covering the main operations for trace data (list, get, query, clear, summary), the count is well-scoped for a focused OTEL tracing server.
Covers essential tasks like listing, retrieving, searching, clearing, and summarizing traces. Missing individual trace deletion or export, but minor gap given the server's scope.
Maintenance
Related MCP Connectors
MCP observability. Query live traffic, errors, duration, and alerts from your AI agent.
Cloud hosted Okahu MCP server that helps you manage genAI trace data
MCP server for building and testing AI agents with multi-model experimentation and insights.
Query application logs, traces, and metrics from your AI coding assistant via Foam's MCP server.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that instruments Cursor AI agent interactions with OpenTelemetry traces and logs to monitor agent turns and performance. It enables tracking of user queries, assistant responses, and tool usage through GenAI-compliant telemetry spans.MIT
- FlicenseNot gradedqualityBmaintenanceMCP server that exposes code tracing capabilities including journey flows, HTTP seams, and findings from indexed projects, allowing AI assistants to query software architecture.-
- AlicenseNot gradedqualityCmaintenanceAn MCP server that enables AI assistants to query and explore your OpenObserve observability data. Provides read-only access to logs, metrics, and traces for analysis and troubleshooting.5MIT
- AlicenseAqualityDmaintenanceMCP server for AI agent observability, providing trace and span logging, search, latency/tokens/cost metrics, and anomaly detection using an in-memory buffer.655 npmMIT