Skip to main content
mcpSource-backedReview first Safety Privacy

OpenTelemetry MCP Server for Claude

Analyze distributed traces and LLM observability data from Claude — search traces and spans, find errors, list services, analyze LLM token usage, identify slow LLM operations, and discover AI model usage patterns — with the OpenTelemetry MCP server supporting Jaeger, Grafana Tempo, and Traceloop backends.

HarnessClaude CodeCodexCursorClaude Desktop
Review first review before installing

Open the source and read safety notes before installing.

Safety notes

  • All tools are read-only — the server queries trace data but does not modify your application or tracing backend.
  • Trace data may contain sensitive information (request parameters, user IDs, SQL queries) — ensure Claude has appropriate access to this data.

Privacy notes

  • Distributed trace content including service names, operation names, error messages, HTTP parameters, and LLM prompt/response metadata may be surfaced in Claude's context.
  • For Traceloop backend, `BACKEND_API_KEY` is required and grants access to your Traceloop organization's trace data.

Prerequisites

  • An OpenTelemetry-compatible tracing backend: Jaeger (local), Grafana Tempo, or Traceloop Cloud.
  • Services instrumented with OpenTelemetry sending traces to your backend.
  • Python 3.11+ with `uvx` available.
  • An MCP client such as Claude Code or Claude Desktop.

Schema details

Install type
cli
Troubleshooting
No
Source repository stats
Scope
Source repo
Collection metadata
Estimated setup
10 minutes
Difficulty
intermediate
Tool listing metadata
Full copyable content
{
  "mcpServers": {
    "opentelemetry": {
      "command": "uvx",
      "args": ["opentelemetry-mcp"],
      "env": {
        "BACKEND_TYPE": "jaeger",
        "BACKEND_URL": "http://localhost:16686"
      }
    }
  }
}

About this resource

Overview

The OpenTelemetry MCP Server is the official MCP server from Traceloop (makers of OpenLLMetry) that connects Claude to your distributed tracing backend. It supports Jaeger (local/cloud), Grafana Tempo, and Traceloop Cloud as backends. Beyond standard trace search, it includes specialized LLM observability tools: token usage analysis, expensive trace identification, slow LLM operation detection, and AI model discovery. Apache-2.0 licensed, Python 3.11+ required.

Key capabilities

  • Trace search — search traces with filters by service, time range, and duration.
  • Span search — find individual spans across services.
  • Error detection — find traces containing errors or exceptions.
  • Service listing — discover all services reporting to the backend.
  • LLM usage — aggregate token usage and costs across all LLM calls.
  • Model discovery — list all LLM models in use across your system.
  • Performance analysis — identify most expensive and slowest LLM operations.

Tools

Tool Category Purpose
search_traces Tracing Search traces with advanced filters
search_spans Tracing Search individual spans within traces
get_trace Tracing Get complete trace details by trace ID
list_services Discovery List all services reporting to the backend
find_errors Diagnostics Find traces containing errors
get_llm_usage LLM Observability Aggregate token usage across LLM calls
list_llm_models LLM Observability Discover which LLM models are in use
get_llm_model_stats LLM Observability Per-model performance statistics
get_llm_expensive_traces LLM Observability Find traces with highest token consumption
get_llm_slow_traces LLM Observability Find slowest LLM operations

Configuration

Env var Required Purpose
BACKEND_TYPE Yes jaeger, tempo, or traceloop
BACKEND_URL Yes Backend API endpoint
BACKEND_API_KEY For Traceloop Traceloop Cloud API key
MAX_TRACES_PER_QUERY No (default 100) Cap result set size
BACKEND_TIMEOUT No (default 30) Request timeout in seconds

How it compares

Server Trace search LLM token analysis Error detection Backends
OpenTelemetry MCP Yes Yes Yes Jaeger, Tempo, Traceloop
Honeycomb MCP Yes No Yes Honeycomb only
Axiom MCP Yes No Yes Axiom only
Dynatrace MCP Yes No Yes Dynatrace only

OpenTelemetry MCP is the only tracing MCP with dedicated LLM observability tools — token usage, model discovery, and slow AI operation identification — across multiple backends.

Installation

Claude Code (Jaeger local)

claude mcp add opentelemetry \
  -e BACKEND_TYPE=jaeger \
  -e BACKEND_URL=http://localhost:16686 \
  -- uvx opentelemetry-mcp

Claude Code (Grafana Tempo)

claude mcp add opentelemetry \
  -e BACKEND_TYPE=tempo \
  -e BACKEND_URL=https://tempo.example.com \
  -- uvx opentelemetry-mcp

Claude Desktop

{
  "mcpServers": {
    "opentelemetry": {
      "command": "uvx",
      "args": ["opentelemetry-mcp"],
      "env": {
        "BACKEND_TYPE": "jaeger",
        "BACKEND_URL": "http://localhost:16686"
      }
    }
  }
}

Requirements

  • OpenTelemetry-compatible backend (Jaeger, Grafana Tempo, or Traceloop).
  • Instrumented services sending traces.
  • Python 3.11+ with uvx (from uv).
  • An MCP client (Claude Code or Claude Desktop).

Security

  • Read-only access to your tracing backend.
  • Trace data may contain sensitive application data — ensure appropriate access controls on the backend itself.

Source Verification Notes

Verified on 2026-06-18:

  • Repository traceloop/opentelemetry-mcp-server (Apache-2.0) on PyPI as opentelemetry-mcp (v0.2.2) documents the uvx opentelemetry-mcp install, BACKEND_TYPE/BACKEND_URL/ BACKEND_API_KEY configuration, support for Jaeger/Tempo/Traceloop backends, all ten tools including the LLM-specific observability tools, Python 3.11+ requirement, and 191 stars.
  • Claude Code MCP documentation at code.claude.com/docs/en/mcp describes the stdio connector pattern used above.

Source citations

Add this badge to your README

Show that OpenTelemetry MCP Server for Claude is listed on HeyClaude. Paste this Markdown into your README — it renders the badge and links back to this page.

Listed on HeyClaude
[![Listed on HeyClaude](https://heyclau.de/badge/mcp/opentelemetry-mcp-server.svg)](https://heyclau.de/entry/mcp/opentelemetry-mcp-server)

How it compares

OpenTelemetry MCP Server for Claude side by side with 3 alternatives on trust, install, platform support, and disclosed safety notes — all from reviewed registry metadata.

FieldOpenTelemetry MCP Server for Claude

Analyze distributed traces and LLM observability data from Claude — search traces and spans, find errors, list services, analyze LLM token usage, identify slow LLM operations, and discover AI model usage patterns — with the OpenTelemetry MCP server supporting Jaeger, Grafana Tempo, and Traceloop backends.

Open dossier
ConfigCat MCP Server for Claude

Manage ConfigCat feature flags from Claude — create, update, and delete flags and targeting rules, manage environments, find and clean up stale flags, and audit change history — with the official ConfigCat MCP server and its 52 tools for the full ConfigCat Management API.

Open dossier
Honeycomb MCP Server for Claude

Connect Claude to Honeycomb observability data — query traces and events, investigate alerts, manage boards and triggers, create SLOs, and cross-reference production behavior with your codebase — with the official Honeycomb hosted MCP server.

Open dossier
Linux MCP Server for Claude

Run Linux system diagnostics from Claude — inspect CPU, memory, disk, network, services, processes, and journal logs — with the official Linux MCP Server from Red Hat's RHEL Lightspeed team, supporting both local and remote SSH-connected hosts.

Open dossier
Trust
Install riskReview firstReview firstReview firstReview first
Notes Safety Privacy Safety Privacy Safety Privacy Safety Privacy
Categorymcpmcpmcpmcp
Sourcesource-backedsource-backedsource-backedsource-backed
AuthorTraceloopConfigCatHoneycombRed Hat RHEL Lightspeed
Added2026-06-182026-06-182026-06-182026-06-18
Platforms
Claude CodeCodexCursorClaude Desktop
Claude CodeClaude Desktop
Claude CodeClaude Desktop
Claude CodeClaude Desktop
Source repo
Safety notesAll tools are read-only — the server queries trace data but does not modify your application or tracing backend. Trace data may contain sensitive information (request parameters, user IDs, SQL queries) — ensure Claude has appropriate access to this data.Tools can create, update, and delete feature flags, targeting rules, environments, and segments — changes affect live feature flag configuration. Use `list-staleflags` before deleting flags to identify zombie flags and avoid breaking active SDKs.The server is hosted by Honeycomb (AWS-backed) and authenticated via OAuth 2.1 or API key — write-scoped access can create/update Boards, Triggers, and SLOs. Writing to Honeycomb resources (boards, triggers, SLOs) requires the `create` scope; verify you grant only the scopes your workflow needs. Canvas investigations and alert management are write operations — review Claude's proposed changes before executing in production environments.The default `fixed` toolset is read-only — no changes are made to the system; only diagnostic information is retrieved. Set `LINUX_MCP_TOOLSET=run_script` to enable script execution — this allows arbitrary command execution on the host; only enable in trusted environments. For remote hosts, `LINUX_MCP_SSH_KEY_PATH` is used for key-based SSH authentication — ensure the key is protected with appropriate permissions.
Privacy notesDistributed trace content including service names, operation names, error messages, HTTP parameters, and LLM prompt/response metadata may be surfaced in Claude's context. For Traceloop backend, `BACKEND_API_KEY` is required and grants access to your Traceloop organization's trace data.Feature flag configurations, targeting rules, audience segments, SDK keys, and audit log entries from your ConfigCat account are surfaced in Claude's context. `CONFIGCAT_API_USER` and `CONFIGCAT_API_PASS` are Management API credentials — keep them in the MCP config env and never commit them to version control.Trace data, event fields, alert details, and query results from Honeycomb are sent through Honeycomb's hosted MCP endpoint and surfaced in Claude's context. Honeycomb API keys (`KEY_ID:SECRET_KEY` format) are secrets — store them in your MCP client config or environment, never in repositories.System information including hostname, OS release, CPU model, active network connections, service names, process names, and journal log content are surfaced in Claude's context. Journal logs may contain sensitive application data — scope `LINUX_MCP_ALLOWED_LOG_PATHS` to limit which logs are readable.
Prerequisites
  • An OpenTelemetry-compatible tracing backend: Jaeger (local), Grafana Tempo, or Traceloop Cloud.
  • Services instrumented with OpenTelemetry sending traces to your backend.
  • Python 3.11+ with `uvx` available.
  • An MCP client such as Claude Code or Claude Desktop.
  • A ConfigCat account — log in at app.configcat.com.
  • Management API credentials: My Account → Public API Credentials → + Create new credentials (these are separate from SDK keys).
  • Node.js with `npx` available.
  • An MCP client such as Claude Code or Claude Desktop.
  • A Honeycomb account — any plan including the free tier.
  • For OAuth: authenticate via browser on first tool use.
  • For API key: use format `HONEYCOMB_API_KEY=<KEY_ID>:<SECRET_KEY>` in your MCP client config.
  • EU customers should use `https://mcp.eu1.honeycomb.io/mcp` instead of the US endpoint.
  • A Linux system running locally or accessible via SSH.
  • Python with `uvx` available.
  • An MCP client such as Claude Code or Claude Desktop.
Install
claude mcp add opentelemetry -e BACKEND_TYPE=jaeger -e BACKEND_URL=http://localhost:16686 -- uvx opentelemetry-mcp
claude mcp add configcat -e CONFIGCAT_API_USER=<your-api-user> -e CONFIGCAT_API_PASS=<your-api-pass> -- npx -y @configcat/mcp-server
claude mcp add honeycomb --transport http https://mcp.honeycomb.io/mcp
claude mcp add linux -- uvx linux-mcp-server
Config
{
  "mcpServers": {
    "opentelemetry": {
      "command": "uvx",
      "args": ["opentelemetry-mcp"],
      "env": {
        "BACKEND_TYPE": "jaeger",
        "BACKEND_URL": "http://localhost:16686",
        "MAX_TRACES_PER_QUERY": "100",
        "BACKEND_TIMEOUT": "30"
      }
    }
  }
}
{
  "mcpServers": {
    "configcat": {
      "command": "npx",
      "args": ["-y", "@configcat/mcp-server"],
      "env": {
        "CONFIGCAT_API_USER": "<your-api-user>",
        "CONFIGCAT_API_PASS": "<your-api-pass>",
        "CONFIGCAT_BASE_URL": "https://api.configcat.com"
      }
    }
  }
}
{
  "mcpServers": {
    "honeycomb": {
      "command": "npx",
      "args": ["mcp-remote", "https://mcp.honeycomb.io/mcp"]
    }
  }
}
{
  "mcpServers": {
    "linux": {
      "command": "uvx",
      "args": ["linux-mcp-server"],
      "env": {
        "LINUX_MCP_TOOLSET": "fixed",
        "LINUX_MCP_COMMAND_TIMEOUT": "30"
      }
    }
  }
}
Citations
ClaimUnclaimedUnclaimedUnclaimedUnclaimed

Signals

Loading live community signals…

More like this, weekly

A short, calm digest of reviewed Claude resources. Unsubscribe any time.