Traceloop MCP server: 11 tools, three backends

A vendor server that treats its own product as one backend of three, what its language-model tools measure, and the HTTP default worth changing.

Last verified 1 September 2026 · from The Traceloop repository, PyPI and the server's own tools/list response

This page is one of 90 in a directory of monitoring and developer tools. Each page checks what an AI coding agent can get out of the tool through its MCP server, the connector that lets the agent query the tool directly.

What is the Traceloop MCP server?

It is Traceloop's server for the Model Context Protocol. Traceloop builds OpenLLMetry, its open-source instrumentation for model calls, so the server reads traces that already follow OpenTelemetry conventions.

Because it speaks to the convention rather than to one store, the same 11 tools reach a self-hosted Jaeger, a Grafana Tempo or Traceloop's own backend. Only the connection flags change.

The language-model tools rely on OpenLLMetry's attributes. list_llm_tools_tool finds tool calls by matching traceloop.span.kind == tool, which means a trace instrumented some other way will not appear in its results.

Traceloop focuses on agent observability and can surface general traces from production. Code review and CI are outside that trace-based surface.

Traceloop answers what model calls did and what they consumed. It names the slowest traces, the heaviest traces by token count, and the models in use. It has no metrics or logs, so a production investigation needs a second connector.

What can an AI agent do with Traceloop?

Run list_services first. It returns the service names the other tools take as arguments, and only then can the agent compose a trace query. A backend holding several environments answers for whichever one the connection points at.

What connecting costs before the first question

A context window is the amount of text a model can hold at once, and connecting uses some of it before the agent asks anything. Every tool the server registers sends its name, description and input schema to the model when the session starts. The tool list is charged whether or not a single tool is called.

11 tools cost between 3,539 and 6,528 tokens, about 1.8% to 3.3% of a 200,000-token window.

The descriptions carry it, at 701 characters on average against 479 for the schemas. search_traces alone runs to 2,002 characters, because it documents a generic filter system alongside its simple parameters.

Encodings: GPT-5.6, GPT-5.5 o200k_base; GPT-4, GPT-3.5 cl100k_base; Claude Haiku 4.5 to Opus 5 count_tokens. Counted 24 August 2026 from tools/list on the released PyPI package 0.2.2, run locally in a clean virtual environment with no backend configured.

Registration is static, so no backend answered. Figures cover name, description and input schema. The two models in column one share the o200k_base encoding, so they get one count. The spread is formatting, about 50%. Reasoning tokens are output, spent per request. The tool list is input, charged once at connection.

The Claude figures are measured rather than encoded. Anthropic publishes no local tokenizer, so the definitions were sent to the API's count_tokens endpoint and a no-tools baseline subtracted. The range covers two tokenizer generations rather than two serializations. Haiku 4.5 and Opus 4.6 sit at the low end, Opus 5 and Sonnet 5 at the high end. The gap between them is about a quarter.

Can Traceloop watch your own AI agents?

This connector is unusual in the table below: it is strong on cost and empty on evaluation. Counted from the released package's own tools/list response on 24 August 2026.

Traceloop MCP server limits: where answers come back incomplete

The limits below come from the server reading a convention rather than a product database.

How to configure Traceloop MCP for agents

1. 1

   Choose the backend explicitly

   --backend takes jaeger, tempo or traceloop, and each expects its own URL. Nothing infers it for you.

2. 2

   Set environments for the Traceloop backend

   --environments takes a comma-separated list, and omitting it leaves the scope of every answer implicit.

3. 3

   Change the HTTP host if you use HTTP

   --host defaults to 0.0.0.0, which binds every interface on the machine.

4. 4

   Expect model tools to depend on instrumentation

   They read OpenLLMetry attributes, so traces produced by other libraries answer the general tools but not the model ones.

Paste this into your agent’s instructions

The same tools answer from three different backends, and the model tools depend on a specific attribute being present. The block makes both visible.

When you answer using Traceloop MCP tools, state:
- The backend you queried: jaeger, tempo or traceloop.
- The service and time range the answer covers.
- Whether a claim came from a model tool. Those read
  OpenLLMetry attributes and miss other instrumentation.
Never state that data does not exist. State that no traces
matched the filters above.
Write your answer in ASD-STE100 Simplified Technical
English. Use short sentences with one idea in each.

Do you need the MCP server at all?

Only for the model tools. For Jaeger or Tempo alone this server is a convenience over each store's own API, and a small one at 3,539 tokens.

The connector earns its place through the model tools. Ranking traces by token usage or comparing model latency percentiles is not something a general tracing API offers.

For metrics and logs alongside traces, Grafana reaches all three through its datasources, and Tempo is one of them.

Connect this for questions about model calls. Reach for Grafana when the question widens to metrics or logs.

Traceloop MCP server setup

The package installs from PyPI as opentelemetry-mcp and exposes an entry point of the same name. Transport defaults to stdio.

Every connection needs a backend type and a URL. The API key is only required by backends that ask for one.

claude mcp add-json "traceloop" '{"command":
  "opentelemetry-mcp",
  "args":["--backend","traceloop",
          "--environments","production"],
  "env":{"BACKEND_API_KEY":"<your-key>"}}'

{"mcpServers":{"traceloop":{
  "command":"opentelemetry-mcp",
  "args":["--backend","jaeger",
          "--url","http://localhost:16686"]}}}

[mcp_servers.traceloop]
command = "opentelemetry-mcp"
args = ["--backend", "tempo", "--url", "https://tempo.internal"]
env = { BACKEND_API_KEY = "<your-key>" }

Every other client

Each block below is the configuration for one client, with the file path and the key that client expects.

{"mcpServers":{"traceloop":{"command":"opentelemetry-mcp",
  "args":["--backend","jaeger","--url","http://localhost:16686"]}}}

{"mcpServers":{"traceloop":{"command":"opentelemetry-mcp",
  "args":["--backend","jaeger","--url","http://localhost:16686"]}}}

{"servers":{"traceloop":{"command":"opentelemetry-mcp",
  "args":["--backend","jaeger","--url","http://localhost:16686"]}}}

{"mcpServers":{"traceloop":{"command":"opentelemetry-mcp",
  "args":["--backend","jaeger","--url","http://localhost:16686"]}}}

BACKEND_API_KEY=<your-key> opentelemetry-mcp \
  --transport http --host 127.0.0.1 --port 8000 \
  --backend traceloop --environments production

Read-only access, permissions and security

• HTTP mode binds to 0.0.0.0 by default

  The --host option's own help text names that default, so an HTTP deployment is reachable from every interface unless changed.

• Traces carry prompts

  OpenLLMetry records model call attributes, and get_trace returns all spans with their parsed data, so prompt and completion content can reach the model.

• The API key is the whole boundary

  There are no read-only or scoped modes; the backend credential decides what the agent can see.

• Every tool reads

  No tool in the list creates, updates or deletes anything in a backend.

Troubleshooting

No traces are returned

Check the backend and URL. The same 11 tools register whether or not a backend is reachable, so an unreachable store returns empty rather than failing at startup.

Model tools return nothing but traces exist

The model tools read OpenLLMetry attributes. list_llm_tools_tool matches traceloop.span.kind == tool, so traces instrumented another way answer only the general tools.

Answers cover the wrong environment

For the Traceloop backend, pass --environments with the environments you mean. Without it, the scope of an answer is whatever the backend defaults to.

The HTTP server is reachable from outside

That is the default. --host is 0.0.0.0 unless set, so pass --host 127.0.0.1 for a local-only deployment.

Traceloop MCP server: Reference

What engineers report

The repository is the most active signal, and its distance from the vendor's own product is the finding.

“Large JSON responses from MCP tools consume significant tokens when passed to LLMs. ... Token limits force truncation of valuable data, reducing context completeness.”

Repository facts from the GitHub API and PyPI, retrieved 24 August 2026. Tool counts and sizes come from the released package's own tools/list response, captured in a clean virtual environment.

Should you connect an agent to Traceloop?

Yes. Best for stdio transport with an explicit backend, and --environments set when the backend is Traceloop.

Strongest fit

Teams running OpenLLMetry who want model-call questions answered from whichever trace store they already have.

Main advantage

The same 11 tools work against Jaeger, Tempo or Traceloop, so the connector survives a change of backend.

Main weakness

The model tools depend on OpenLLMetry attributes, so other instrumentation answers only the general tools.

Operational risk

HTTP transport binds every interface by default, and traces can carry prompt content into the model.

Frequently asked questions