SigNoz MCP Server

A Model Context Protocol (MCP) server that provides seamless access to SigNoz observability data through AI assistants and LLMs. Query metrics, traces, logs, alerts, dashboards, and services using natural language.

📖 Full Documentation

Table of Contents

• Connect to SigNoz Cloud
• Self-Hosted Installation
• Connect to Self-Hosted SigNoz
• MCP Protocol Compatibility
• What Can You Do With It?
• Available Tools
• Environment Variables
• Claude Desktop Extension
• End-to-End Tests
• Architecture
• Contributing

Connect to SigNoz Cloud

Connect your AI tool to SigNoz Cloud’s hosted MCP server. No installation is required; just add the hosted MCP URL and authenticate.

https://mcp..signoz.cloud/mcp

Make sure you select the correct region that matches your SigNoz Cloud account. Using the wrong region will result in authentication failures.

Find your region under Settings → Ingestion in SigNoz, or see the SigNoz Cloud region reference.

One-Click Install Links

GitHub does not reliably make custom-protocol links like cursor:// and vscode: clickable in README rendering.

Use the documentation page for one-click install buttons:

• Open one-click install links for Cursor
• Open one-click install links for VS Code

If you prefer, use the manual configuration examples below in this README.

Cursor

Manual Configuration

Add this configuration to .cursor/mcp.json:

{
  "mcpServers": {
    "signoz": {
      "url": "https://mcp..signoz.cloud/mcp"
    }
  }
}

Need help? See the Cursor MCP docs.

VS Code / GitHub Copilot

Manual Configuration

Add this configuration to .vscode/mcp.json:

{
  "servers": {
    "signoz": {
      "type": "http",
      "url": "https://mcp..signoz.cloud/mcp"
    }
  }
}

Need help? See the VS Code MCP docs.

Claude Desktop

Add SigNoz Cloud as a custom connector in Claude Desktop:

1. Open Claude Desktop.
2. Go to Settings → Developer (or Features, depending on your version).
3. Click Add Custom Connector or Add Remote MCP Server.
4. Enter your SigNoz MCP URL: https://mcp..signoz.cloud/mcp

When prompted, complete the authentication flow.

Claude Code

Run this command to add the hosted SigNoz MCP server:

claude mcp add --scope user --transport http signoz https://mcp..signoz.cloud/mcp

After configuring the MCP server, authenticate in a terminal:

claude /mcp

Select the signoz server and complete the authentication flow.

OpenAI Codex

Run this command to add the hosted SigNoz MCP server:

codex mcp add signoz --url https://mcp..signoz.cloud/mcp

Or add this configuration to config.toml:

[mcp_servers.signoz]
url = "https://mcp..signoz.cloud/mcp"

After adding the server, authenticate:

codex mcp login signoz

Then run /mcp inside Codex to verify the connection.

Grok Build

Run this command to add the hosted SigNoz MCP server:

grok mcp add -t http signoz https://mcp..signoz.cloud/mcp

Or add this configuration to ~/.grok/config.toml:

[mcp_servers.signoz]
url = "https://mcp..signoz.cloud/mcp"
enabled = true

Adding the server does not authenticate it. Start Grok Build, run /mcps, select the signoz server, and complete the OAuth flow in your browser:

grok

/mcps

No API key is stored in the config file; credentials are saved separately once the OAuth flow completes.

Use -s project on the add command to write to ./.grok/config.toml instead, so the server is shared with everyone working in that directory.

Verify the connection with:

grok mcp list
grok mcp doctor

SigNoz Cloud Authentication

When you add the hosted MCP URL to your client, the client initiates an authentication flow. You will be prompted to enter:

1. Your SigNoz instance URL (for example, your-instance.signoz.cloud). Protocol-less URLs are accepted; paths, query parameters, and fragments are ignored.
2. Your API key

Create an API key in Settings → API Keys in SigNoz. Only Admin users can create API keys.

Self-Hosted Installation

Download Binary (Recommended)

Download the latest binary from GitHub Releases:

# macOS (Apple Silicon)
curl -L https://github.com/SigNoz/signoz-mcp-server/releases/latest/download/signoz-mcp-server_darwin_arm64.tar.gz | tar xz

# macOS (Intel)
curl -L https://github.com/SigNoz/signoz-mcp-server/releases/latest/download/signoz-mcp-server_darwin_amd64.tar.gz | tar xz

# Linux (amd64)
curl -L https://github.com/SigNoz/signoz-mcp-server/releases/latest/download/signoz-mcp-server_linux_amd64.tar.gz | tar xz

This extracts a signoz-mcp-server binary in the current directory. Move it somewhere on your PATH or note the absolute path for the config below.

Go Install

go install github.com/SigNoz/signoz-mcp-server/cmd/server@latest

The binary is installed as server to $GOPATH/bin/ (default: $HOME/go/bin/server). You may want to rename it:

mv "$(go env GOPATH)/bin/server" "$(go env GOPATH)/bin/signoz-mcp-server"

Docker

Docker images are available on Docker Hub:

docker pull signoz/signoz-mcp-server:latest

Run in HTTP mode:

docker run -p 8000:8000 \
  -e TRANSPORT_MODE=http \
  -e MCP_SERVER_PORT=8000 \
  -e SIGNOZ_URL=https://your-signoz-instance.com \
  -e SIGNOZ_API_KEY=your-api-key \
  signoz/signoz-mcp-server:latest

Use a specific version tag (e.g. v0.1.0) instead of latest for pinned deployments.

Build from Source

git clone https://github.com/SigNoz/signoz-mcp-server.git
cd signoz-mcp-server
make build

The binary is at ./bin/signoz-mcp-server.

Connect to Self-Hosted SigNoz

Prerequisites

• A running SigNoz instance on the latest release. Each server release targets the latest SigNoz release and is not tested against older versions; see CHANGELOG.md for breaking changes.
• A SigNoz API key (Settings → API Keys in the SigNoz UI)
• The signoz-mcp-server binary (see Self-Hosted Installation)

Stdio Mode (Claude Desktop / Cursor / Any MCP Client)

Add this to your MCP client config (claude_desktop_config.json, .cursor/mcp.json, etc.). Replace the command path with the absolute path to your signoz-mcp-server binary:

{
    "mcpServers": {
        "signoz": {
            "command": "/absolute/path/to/signoz-mcp-server",
            "args": [],
            "env": {
                "SIGNOZ_URL": "https://your-signoz-instance.com",
                "SIGNOZ_API_KEY": "your-api-key-here",
                "LOG_LEVEL": "info"
            }
        }
    }
}

HTTP Mode

HTTP mode listens on all interfaces by default. Set MCP_SERVER_HOST=127.0.0.1 when the server should accept loopback connections only.

Memory footprint

The server keeps the SigNoz docs search index in memory. With stemming on titles and headings and a single standard-analyzed body field, the embedded 746-page index used 28 to 36 MiB of resident heap across eight local Go 1.26 whole-package test runs. Build peaks ranged from 97 to 134 MiB above the pre-build heap baseline, using 64-page batches. These are index measurements, not whole-process RSS or container memory guarantees; request handling and refresh work add memory.

A scheduled refresh (default every 6h) first compares the live sitemap with the served one and stops there when it is unchanged. Otherwise it revalidates every page with If-None-Match and touches the index only when at least one page’s content changed. A change set covering up to a quarter of the pages is applied to the live index in place; a larger one, the 25th in-place update on the same index, and any forced refresh (default every 24h) that finds changed content rebuild the index from scratch, which also compacts the segments that in-place updates leave behind. Full rebuilds use 64-page batches. In-place updates use one atomic batch bounded by the quarter-of-pages threshold, not the full-build batch size.

Recommendations for containerized HTTP deployments:

• Set the memory limit to at least 512Mi, and monitor memory during refreshes and concurrent requests. The highest measured index-only build peak is 134 MiB above baseline and the resident index is 28 to 36 MiB; rebuilds also retain the serving index. Setting Go’s GOMEMLIMIT is optional: it can reclaim garbage earlier but cannot shrink live data inside an index batch.
• Set both SIGNOZ_DOCS_REFRESH_INTERVAL=0 and SIGNOZ_DOCS_FULL_REFRESH_INTERVAL=0 when you would rather serve the docs snapshot that shipped with the release than pay any refresh. New docs pages then arrive with the next server upgrade. Setting only the first keeps the daily forced refresh.
• Every refresh logs docs refresh starting and ends with a completion or failure line, for example docs refresh no-op; sitemap unchanged, docs refresh found no page changes; index kept, docs refresh applied delta, docs refresh rebuilt index, or a docs refresh failed / docs full refresh failed warning. A refresh normally finishes within a few minutes. A container whose last docs line is docs refresh starting, docs refresh fetching pages, or docs refresh rebuilding index and that then restarted most likely died mid-refresh.

With OAuth (Multi-Tenant / Cloud)

Start the server:

TRANSPORT_MODE=http \
MCP_SERVER_PORT=8000 \
OAUTH_ENABLED=true \
OAUTH_TOKEN_SECRET=$(openssl rand -base64 32) \
OAUTH_ISSUER_URL=https://your-public-mcp-url.com \
./signoz-mcp-server

Client config needs just the URL, no keys:

{
    "mcpServers": {
        "signoz": {
            "url": "https://your-public-mcp-url.com/mcp"
        }
    }
}

The client discovers OAuth endpoints automatically, opens a browser for credentials, and handles token exchange.

Without OAuth (Simple Setup)

The API key and SigNoz URL only need to be provided in one place: the server or the client.

Option A — Credentials on the server (simpler client config):

SIGNOZ_URL=https://your-signoz-instance.com \
SIGNOZ_API_KEY=your-api-key \
TRANSPORT_MODE=http \
MCP_SERVER_PORT=8000 \
./signoz-mcp-server

{
    "mcpServers": {
        "signoz": {
            "url": "http://localhost:8000/mcp"
        }
    }
}

Option B — API key on the client (server holds the URL, client sends the key):

SIGNOZ_URL=https://your-signoz-instance.com \
TRANSPORT_MODE=http \
MCP_SERVER_PORT=8000 \
./signoz-mcp-server

{
    "mcpServers": {
        "signoz": {
            "url": "http://localhost:8000/mcp",
            "headers": {
                "SIGNOZ-API-KEY": "your-api-key-here"
            }
        }
    }
}

MCP Protocol Compatibility

SigNoz uses the official MCP Go SDK v1.8.0 and supports both current lifecycle models over HTTP and stdio:

The HTTP /mcp endpoint is stateless and sessionless. MCP messages use JSON POST requests and successful responses use application/json; the server does not issue or require Mcp-Session-Id. GET /mcp and DELETE /mcp return 405 Method Not Allowed, so deployments need neither sticky routing nor the old GET listener/heartbeat. Existing client configuration does not change.

Stdio input has a 16 MiB frame limit. Split larger requests into smaller calls. MCP_MAX_REQUEST_BYTES controls HTTP request bodies only.

The server intentionally does not advertise the deprecated logging capability. Discovery ordering is not a compatibility guarantee. Unknown tools, resources, and prompts use the official SDK’s standard invalid-params behavior rather than legacy implementation-specific wording or error codes.

HTTP Probe Endpoints

HTTP mode exposes unauthenticated probe endpoints. New Kubernetes deployments should use /livez for livenessProbe and /readyz for readinessProbe.

What Can You Do With It?

"Show me all available metrics"
"What's the p99 latency for http_request_duration_seconds?"
"List all active alerts"
"Show me error logs for the paymentservice from the last hour"
"How many errors per service in the last hour?"
"Search traces for the checkout service from the last hour"
"Get details for trace ID abc123"
"Create a dashboard with CPU and memory widgets"
"How do I send Docker logs to SigNoz?"

Available Tools

Tool metadata: every tool accepts searchContext. Copy the user’s entire original request verbatim, including preflight or confirmation context; it is used for MCP observability and is not forwarded to SigNoz APIs.

Input validation: calls are never rejected for schema mismatches. Arguments are validated against each tool’s advertised schema; a mismatched call still runs best-effort, and the successful result carries a deterministic appended Input validation notice: naming the affected top-level parameter when it can be derived safely from the advertised schema. Complex root-only mismatches use a generic fallback. Mismatches are also counted in the mcp.tool.validation.mismatches metric. Arguments a tool’s schema does not declare add no notice and are handled as before: most tools ignore them, and a few reject them with a coded error, such as the retired log query alias or an unknown notification-channel field. They are also logged at WARN with their names and counted in the same metric under path `` and constraint undeclared_argument.

Upstream errors: upstream SigNoz 401 and 403 tool failures carry a stable structured code (UNAUTHORIZED or PERMISSION_DENIED) and numeric status. Recognized SigNoz error envelopes may also include bounded upstreamURL, upstreamSuggestions, upstreamDetails ([{message, suggestions}]), and upstreamRetry ({delay} in nanoseconds); the same recovery guidance appears in agent-readable text. Unrecognized bodies use the local status-derived coded fallback instead of raw passthrough, and authorization failures still name the failed tool and immediate recovery action. This error-only addition does not change tool names, schemas or descriptions, success payloads, resources or templates, or prompts.

For detailed usage and examples, see the full documentation.

Resource deep links: the resource read tools (signoz_list_dashboards, signoz_get_dashboard, signoz_list_alerts, signoz_list_alert_rules, signoz_get_alert, signoz_list_services, signoz_search_traces, signoz_get_trace_details) and the dashboard write tools (signoz_create_dashboard, signoz_update_dashboard, signoz_patch_dashboard, signoz_import_dashboard) include a webUrl field when the request carries a SigNoz instance URL: an absolute deep link to the resource in the SigNoz web UI (per result row for signoz_search_traces). The MCP server discovers the browser base from each SigNoz backend’s global.external_url. API requests keep using the request’s backend URL. See Browser links for self-hosted SigNoz.

Agent Routing Guidance

Use signoz_search_docs for topical discovery when no exact documentation page is selected, then signoz_fetch_doc for the chosen page or heading. Use live data tools for tenant telemetry, alert state, dashboards, saved views, and notification channels.

Docs tools use the same authentication path as other MCP tools.

Available Resources

Resource Template Migration

The live signoz://dashboard/{id}/summary and signoz://alert/{id}/summary resource templates are retired. resources/templates/list now returns an empty catalog. Use signoz_get_dashboard for a dashboard definition. For the former alert summary, call signoz_get_alert, then signoz_get_alert_history; omit the time range for the same six-hour window and set limit: 10 and order: "desc" for the closest history result.

Environment Variables

The MCP server does not run an OTLP log exporter; logs are emitted as JSON to stderr. OTEL_LOGS_EXPORTER is therefore not used.

Browser links for self-hosted SigNoz

Note: Set global.external_url on the SigNoz server to the URL users open in their browser. The MCP server reads it from GET /api/v1/global/config, so the instance URL is configured in one place.

For example, add this environment variable to the SigNoz deployment and restart SigNoz:

SIGNOZ_GLOBAL_EXTERNAL__URL=https://observe.example.com

There are two underscores before URL. The equivalent SigNoz YAML configuration is:

global:
  external_url: https://observe.example.com

Keep SIGNOZ_URL on the MCP server pointed at its reachable API address, such as http://signoz:8080. If the deployment uses a path prefix, include it in the API address as required by SigNoz and your proxy routing. Configure a backend path in SIGNOZ_URL: per-request URLs supplied through OAuth or X-SigNoz-URL currently support origins only.

Browser links use the discovered URL, including any configured base path, while API requests retain their destination and credentials. Each tenant client caches discovery for 15 minutes. An unset external URL uses the request’s API URL; unavailable or invalid global configuration logs a warning and retries discovery after one minute. Authentication and permission errors are returned to the client.

Claude Desktop Extension

Building the Bundle

Requires Node.js. See Anthropic MCPB for details.

make bundle

Installing

1. Open Claude Desktop → Settings → Developer → Edit Config → Add bundle.mcpb
2. Select ./bundle/bundle.mcpb
3. Enter your SIGNOZ_URL, SIGNOZ_API_KEY, and optionally LOG_LEVEL
4. Restart Claude Desktop

For browser links, configure SigNoz’s global external URL.

End-to-End Tests

The e2e suite under tests/ runs the server (built from the working tree) against a real SigNoz instance provisioned by foundry and drives it over the MCP HTTP transport:

make test-e2e          # cast SigNoz, run the suites, tear down
make test-e2e-reuse    # rerun against the cached environment

Requires Docker, foundryctl, Go, and uv. See tests/README.md for the full workflow.

Architecture

For a detailed overview of request flow, component interactions, and design decisions, see docs/architecture.md.

Contributing

See CONTRIBUTING.md for development workflow, required docs/manifest sync for MCP changes, and PR checklist.

Made with ❤️ for the observability community