LABSCO SUMMARY

Read-only access to your observability data, from the editor

Nothing here mutates: no dashboard updates, no metric or log writes, no monitor deletions, which is what makes it reasonable to attach to a production tenant mid-incident. The pairing that earns its place is fetching a monitor's configuration next to the logs that tripped it, without leaving the code you are reading.

What it is

Chronosphere's MCP server for its Observability Platform. It connects a large language model to your tenant so telemetry and platform resources can be queried from the client, and it is read-only by design.

What you get

Telemetry queries over change events, metrics, logs and traces
Single resources by name: get_dashboard, get_monitor, get_slo, get_drop_rule, get_rollup_rule, get_mapping_rule, get_recording_rule, get_notification_policy
List tools beside them — list_dashboards, list_drop_rules, list_mapping_rules — for finding the one you want
Log tools that go past search: get_log fetches a message by its ID, get_log_histogram shapes a query over time
get_events_metadata, which tells you what properties events can be queried on
A separate documentation MCP server that serves public Chronosphere docs and needs no authentication

Requirements

A Chronosphere tenant, and either an API token or OAuth. The token can be a personal access token — actions are then attributed to you and bounded by your team's permissions — or a service-account token for programmatic access; Chronosphere recommends holding it in a separate file or a Kubernetes Secret and passing it through an environment variable. OAuth needs a client that supports it, and has been tested with Claude Code, Cursor, Codex and Gemini.

Setup effort

Get your endpoint, then paste it — add your endpoint to your client

See installation options

USE CASES

01

Finding the root cause behind an alert

Fetch the monitor's configuration to see what it is actually watching, then pull the error logs with stack traces and read them against the code in the same editor.

get_monitorget_logget_log_histogram

02

Writing a PromQL query for a service you do not know

List the dashboards and recording rules already defined for the service, then build the query from what is there rather than from the metric name you guessed.

list_dashboardsget_dashboardget_recording_rule

03

Working out why data is or is not being dropped

List the active shaping rules and read the one that matches, so a gap in a dashboard is traced to a rule instead of to the pipeline in general.

list_drop_rulesget_drop_ruleget_mapping_rule

38 tools

Listed in project docs. Your client may show a different list.

get_classic_dashboard

get_dashboard

get_drop_rule

get_mapping_rule

get_monitor

get_notification_policy

get_recording_rule

get_rollup_rule

get_slo

list_classic_dashboards

list_dashboards

list_drop_rules

list_mapping_rules

list_monitors

list_notification_policies

BEFORE YOU INSTALL

What to know first

Tools you get

38 tools named in the project's documentation.

Requires

A client that can reach a remote MCP server over HTTP
CHRONOSPHERE_API_TOKEN in your environment

INSTALLATION

Connect your client

MCP Clients

Cursor

To hide tools, add the header X-Chrono-MCP-Disable-Tools with a comma-separated list of tool names, for example query_logs_range,render_prometheus_range_query. Leave out the Authorization header to sign in with OAuth instead, if your client supports it.

CURSOR · JSON

{
  "mcpServers": {
    "chronosphere": {
      "url": "https://<YOUR_ORG_NAME>.chronosphere.io/api/mcp/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_BEARER_TOKEN>"
      }
    }
  }
}

VS Code

To hide tools, add the header X-Chrono-MCP-Disable-Tools with a comma-separated list of tool names, for example query_logs_range,render_prometheus_range_query. Leave out the Authorization header to sign in with OAuth instead, if your client supports it.

VS CODE · JSON

{
  "servers": {
    "chronosphere": {
      "url": "https://<YOUR_ORG_NAME>.chronosphere.io/api/mcp/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_BEARER_TOKEN>"
      }
    }
  }
}

Claude Code

Set CHRONOSPHERE_ORG_NAME and CHRONOSPHERE_API_TOKEN in your shell first. To hide tools, add -H "X-Chrono-MCP-Disable-Tools: query_logs_range,render_prometheus_range_query" with your own comma-separated list. For OAuth, leave out the Authorization header, then type /mcp in Claude Code and select the server to log in.

CLAUDE CODE · TERMINAL

claude mcp add -t http \
  -H "Authorization: Bearer ${CHRONOSPHERE_API_TOKEN}" \
  chronosphere "https://${CHRONOSPHERE_ORG_NAME}.chronosphere.io/api/mcp/mcp"

Codex

CODEX · TOML

experimental_use_rmcp_client = true
[mcp_servers.chronosphere]
url = "https://<YOUR_ORG_NAME>.chronosphere.io/api/mcp/mcp"
bearer_token = "<YOUR_BEARER_TOKEN>"

Gemini CLI

Set CHRONOSPHERE_ORG_NAME and CHRONOSPHERE_API_TOKEN in your shell first. To hide tools, add -H "X-Chrono-MCP-Disable-Tools: query_logs_range,render_prometheus_range_query" with your own comma-separated list. Drop the Authorization header to use OAuth.

GEMINI CLI · TERMINAL

gemini mcp add chronosphere "https://${CHRONOSPHERE_ORG_NAME}.chronosphere.io/api/mcp/mcp" \
  -H "Authorization: Bearer ${CHRONOSPHERE_API_TOKEN}"

Any MCP client — local build

Clone the repository and build the binary

ANY MCP CLIENT — LOCAL BUILD · TERMINAL

git clone https://github.com/chronosphereio/chronosphere-mcp.git
cd chronosphere-mcp
make chronomcp

Add this to your client's MCP config

<YOUR_PATH_TO_REPO> is the absolute path of that clone. config.yaml ships in the repository.

ANY MCP CLIENT — LOCAL BUILD · JSON

{
  "mcpServers": {
    "chronosphere-mcp": {
      "command": "<YOUR_PATH_TO_REPO>/bin/chronomcp",
      "args": [
        "-c",
        "<YOUR_PATH_TO_REPO>/config.yaml"
      ],
      "env": {
        "CHRONOSPHERE_ORG_NAME": "<YOUR_CHRONOSPHERE_ORG_NAME>",
        "CHRONOSPHERE_API_TOKEN": "<YOUR_CHRONOSPHERE_API_TOKEN>"
      }
    }
  }
}

Chronosphere