NewAgent Observability — find failures before customers do.
Back to directory
OpenLIT logo

OpenLIT MCP server: read traces through ClickHouse

OpenLIT instruments MCP clients and servers so their tool calls show up as OpenTelemetry traces. To let an agent read those traces, connect it to the ClickHouse database OpenLIT writes to.

Connector
None official
Coverage
Traces, cost, GPU metrics
Tools
3 in ClickHouse MCP
Working route
Point mcp-clickhouse at OpenLIT

Checked 3 October 2026 · from OpenLIT's documentation index, SDK configuration and Docker Compose file, the openlit GitHub organization, and the official MCP registry

One of 91 guides to monitoring and developer tools. Each covers what an AI coding agent can get out of the tool through MCP, the protocol that lets the agent query the tool directly.

Summary

OpenLIT has not published an MCP server as of 3 October 2026. Its documentation index has three MCP entries, and each one is about observing MCP traffic rather than serving OpenLIT data.

Everything OpenLIT collects lands in ClickHouse, in tables such as otel_traces. ClickHouse publishes its own MCP server, mcp-clickhouse, which runs SQL read-only by default.

If your OpenLIT SDK exports to a different backend, such as Grafana Tempo or Datadog, connect that backend's server instead. OpenLIT documents more than 20 export destinations.

How OpenLIT works with MCP

OpenLIT is an open-source observability platform for LLM and agent applications, licensed Apache 2.0. Its SDK instruments model calls, vector databases and agent frameworks, then sends OpenTelemetry (OTel) data over OTLP, OTel's wire protocol.

MCP appears in OpenLIT as something to watch. Two pages titled "Get started with MCP Monitoring" instrument your MCP clients and servers so each tool call becomes a span. A third, Scanner connectors, scans GitHub repositories for MCP and agent-SDK findings.

A self-hosted install runs an OTLP receiver, a dashboard and ClickHouse, a columnar SQL database. The default Docker Compose file names the database openlit and exposes ClickHouse's HTTP port, 8123.

OpenLIT's REST API covers prompts, Vault secrets, the rule engine, model pricing, API keys and scanner jobs. It has no endpoint for querying traces.

Otter, OpenLIT's built-in chat assistant, does turn questions into read-only SQL over your telemetry. It runs inside the OpenLIT UI, so an external agent cannot call it.

Every vendor here gets the same four checks: official, maintained, distributed and usable. OpenLIT passes 0 of them.

CheckResultEvidence
OfficialFailNot published. OpenLIT's documentation index lists three MCP-related pages on 3 October 2026, and all three cover observing MCP activity.
MaintainedNot applicableApplies to an OpenLIT-published server. The openlit/openlit repository itself is active, with a push on 1 October 2026.
DistributedFailThe official MCP registry returns zero results for OpenLIT, and openlit-mcp does not exist on PyPI or npm.
UsableNot applicableAgents read OpenLIT data through ClickHouse's mcp-clickhouse server, which runs SQL against the database OpenLIT writes to.
Part of the workWhat OpenLIT has hereCan an agent reach it
Agent observability & evalsLLM and agent spans, MCP tool-call spans, evaluation scoresPartial. Readable as SQL through ClickHouse's MCP server, not through OpenLIT
AI cost managementCost per model, user and agent runPartial. Stored as the gen_ai.usage.cost span attribute, so totals need a SQL aggregate
Production observabilityGPU utilization, memory and temperature from the OTel GPU CollectorPartial. Held in the otel_metrics_* tables in the same ClickHouse database

All three rows resolve to one ClickHouse schema. An agent with SQL access can answer trace, cost and GPU questions, provided it knows the OpenTelemetry column names OpenLIT uses.

What can an AI agent do with OpenLIT?

An agent can query what OpenLIT stored, but only through SQL

The MCP Monitoring quickstart wraps your own MCP app with the OpenLIT SDK. It gives you spans to look at, not an endpoint to call.

With mcp-clickhouse connected, the agent lists OpenLIT's tables and writes ClickHouse SQL against them. It has no OpenLIT-specific tools for traces, costs or evaluations.

Guard: Give the agent the table names up front: otel_traces for spans and otel_metrics_* for metrics.

Query results can include full prompts and completions

OpenLIT's SDK records prompt and response text by default, because capture_message_content defaults to True. max_content_length defaults to no truncation.

A broad SELECT over otel_traces can therefore pull customer text into the agent's context.

Guard: Use a ClickHouse user limited to the needed tables, or set capture_message_content=False in the SDK.

Do you need the MCP server at all?

For trace and cost questions, mcp-clickhouse is the shortest route. It exposes run_query, list_databases and list_tables, and refuses writes unless CLICKHOUSE_ALLOW_WRITE_ACCESS is set to true.

If the SDK exports somewhere other than OpenLIT, query that backend instead. OpenLIT documents exporters for Grafana Cloud, Datadog, New Relic, Dynatrace, Elastic, SigNoz and Langfuse, among others.

For prompts, Vault secrets or model pricing, use OpenLIT's REST API. It returns prompts already compiled with your variables and pricing grouped by provider.

Use ClickHouse's MCP server for anything OpenLIT recorded, and OpenLIT's REST API for anything OpenLIT manages.

OpenLIT integration setup

OpenLIT itself needs no MCP configuration. The setups below point ClickHouse's MCP server at the database OpenLIT already writes to.

Claude Code

Runs mcp-clickhouse locally through uv. Port 8123 matches OpenLIT's default Compose file; a managed ClickHouse uses its own host, port and TLS setting.

Terminal
claude mcp add-json openlit-clickhouse '{"command":"uv",
  "args":["run","--with","mcp-clickhouse","--python","3.12","mcp-clickhouse"],
  "env":{"CLICKHOUSE_HOST":"localhost","CLICKHOUSE_PORT":"8123",
         "CLICKHOUSE_USER":"agent_ro","CLICKHOUSE_PASSWORD":"<password>",
         "CLICKHOUSE_SECURE":"false"}}'

Cursor

Same server in .cursor/mcp.json, with the password read from your shell environment rather than written into the file.

Terminal
{"mcpServers":{"openlit-clickhouse":{
  "command":"uv",
  "args":["run","--with","mcp-clickhouse","--python","3.12","mcp-clickhouse"],
  "env":{"CLICKHOUSE_HOST":"localhost","CLICKHOUSE_PORT":"8123",
    "CLICKHOUSE_USER":"agent_ro",
    "CLICKHOUSE_PASSWORD":"${env:OPENLIT_CH_PASSWORD}",
    "CLICKHOUSE_SECURE":"false"}}}}

Every other client

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

A first query: cost by model

OpenLIT's own dashboard widgets read cost from SpanAttributes['gen_ai.usage.cost']. The same expression works from an agent.

Terminal
SELECT SpanAttributes['gen_ai.request.model'] AS model,
       round(sum(toFloat64OrZero(SpanAttributes['gen_ai.usage.cost'])), 4) AS usd
FROM openlit.otel_traces
WHERE Timestamp > now() - INTERVAL 7 DAY
GROUP BY model ORDER BY usd DESC LIMIT 20

Read-only access, permissions and security

  • Create a dedicated ClickHouse user

    OpenLIT's Compose file defaults to the default user with password OPENLIT, which is far too broad for an agent.

  • Leave writes off

    mcp-clickhouse keeps CLICKHOUSE_ALLOW_WRITE_ACCESS=false unless you change it.

  • Expect sensitive text in spans

    Prompts and completions are captured by default, so grant the agent only the tables a task needs.

What the vendor documents

OpenLIT's quickstart says it "automatically instruments MCP alongside LLMs, VectorDBs, and frameworks by default". Its architecture diagram shows the SDK sending OTLP to the OpenLIT receiver, which stores data in ClickHouse for the UI to read.

Should you connect an agent to OpenLIT?

Yes, through ClickHouse, if your OpenLIT data stays in OpenLIT's own database. Best for self-hosted OpenLIT users who want an agent to answer trace and cost questions in SQL.

Strongest fit
Yes, through ClickHouse, if your OpenLIT data stays in OpenLIT's own database.
Main advantage
Traces, cost and GPU metrics share one ClickHouse schema that a SQL-capable agent can read.
Main weakness
The agent has to write SQL against OpenTelemetry tables, with no OpenLIT-specific tools to lean on.
Operational risk
Spans can hold full prompt and completion text, and a broad query hands it to the agent.

From Oodle

One platform for agent traces and infrastructure

Agent traces usually sit in a different product from the rest of your telemetry, so when a slow database makes an agent slow the symptom is in one tool and the cause is in another. Oodle keeps both in one query surface.

See agent observability

Frequently asked questions

Does OpenLIT have an MCP server?

No. As of 3 October 2026 OpenLIT has not published one. Its MCP documentation covers monitoring the MCP clients and servers you run.

How can an agent query OpenLIT traces?

Through ClickHouse. Point the mcp-clickhouse server at the openlit database and query the otel_traces table in SQL.

Is Otter an MCP server?

No. Otter is OpenLIT's in-app chat assistant. It writes read-only SQL over your telemetry, but only inside the OpenLIT UI.

Does OpenLIT trace MCP tool calls?

Yes. The OpenLIT SDK instruments MCP by default, alongside LLM and vector database calls, so tool calls appear as spans.