Tempo MCP Server

What is Tempo MCP Server about?

Tempo MCP Server implements the Model Context Protocol to expose Tempo tracing data as AI‑usable tools. It allows AI agents (e.g., Claude Desktop, Cursor) to run trace queries, retrieve results, and incorporate them into workflows.

How to use Tempo MCP Server?

1. Prerequisites: Install Go 1.21+ and have Docker (optional).
2. Build & run:

   go build -o tempo-mcp-server ./cmd/server
   ./tempo-mcp-server
   

   OR run directly:

   go run ./cmd/server
   

3. HTTP mode (default port 8080, configurable via SSE_PORT):
   • SSE endpoint: http://localhost:8080/sse
   • MCP endpoint: http://localhost:8080/mcp
4. Docker:

   docker build -t tempo-mcp-server .
   docker run -p 8080:8080 --rm -i tempo-mcp-server
   

5. Integration: Add the server to Claude Desktop, Cursor, or n8n configuration using the provided JSON snippets.

Key features of Tempo MCP Server

• Dual communication modes: stdin/stdout (MCP) and HTTP with Server‑Sent Events.
• tempo_query tool with required query parameter and optional filters (url, start, end, limit, auth options).
• Environment variable support (TEMPO_URL, SSE_PORT).
• Ready‑to‑use Docker image and Docker‑Compose setup.
• Example client script (run-client.sh) for quick testing.

Use cases of Tempo MCP Server

• AI‑assisted troubleshooting: Let an LLM automatically fetch recent error traces from Tempo and suggest fixes.
• Automated observability pipelines: Combine with n8n to trigger alerts or ticket creation based on trace patterns.
• Developer assistance: Cursor can call the server to provide live trace data while writing code.
• Dashboard augmentation: Claude Desktop can surface trace information directly in chat.

FAQ from the Tempo MCP Server

Q: Which port does the server listen on? A: Default is 8080; change with the SSE_PORT environment variable.

Q: How does authentication work for Tempo queries? A: Provide username/password for basic auth, or a token for Bearer authentication. These can be passed in the tool request or set via environment variables.

Q: Can I run the server without Docker? A: Yes, compile with Go and execute the binary directly.

Q: What formats are returned by the tempo_query tool? A: The tool returns JSON‑encoded trace metadata limited by the limit parameter.

Q: Is there support for multiple MCP tools? A: Currently only tempo_query is shipped, but the architecture allows adding more handlers under internal/handlers.

Tempo MCP Server

A Go-based server implementation for the Model Context Protocol (MCP) with Grafana Tempo integration.

Overview

This MCP server allows AI assistants to query and analyze distributed tracing data from Grafana Tempo. It follows the Model Context Protocol to provide tool definitions that can be used by compatible AI clients such as Claude Desktop.

Getting Started

Prerequisites

• Go 1.21 or higher
• Docker and Docker Compose (for local testing)

Building and Running

Build and run the server:

# Build the server
go build -o tempo-mcp-server ./cmd/server

# Run the server
./tempo-mcp-server

Or run directly with Go:

go run ./cmd/server

The server now supports two modes of communication:

1. Standard input/output (stdin/stdout) following the Model Context Protocol (MCP)
2. HTTP Server with Server-Sent Events (SSE) endpoint for integration with tools like n8n

The default port for the HTTP server is 8080, but can be configured using the SSE_PORT environment variable.

Server Endpoints

When running in HTTP mode, the server exposes the following endpoints:

• SSE Endpoint: http://localhost:8080/sse - For real-time event streaming
• MCP Endpoint: http://localhost:8080/mcp - For MCP protocol messaging

Docker Support

You can build and run the MCP server using Docker:

# Build the Docker image
docker build -t tempo-mcp-server .

# Run the server
docker run -p 8080:8080 --rm -i tempo-mcp-server

Alternatively, you can use Docker Compose for a complete test environment:

# Build and run with Docker Compose
docker-compose up --build

Project Structure

.
├── cmd/
│   ├── server/       # MCP server implementation
│   └── client/       # Client for testing the MCP server
├── internal/
│   └── handlers/     # Tool handlers
├── pkg/
│   └── utils/        # Utility functions and shared code
└── go.mod            # Go module definition

MCP Server

The Tempo MCP Server implements the Model Context Protocol (MCP) and provides the following tools:

Tempo Query Tool

The tempo_query tool allows you to query Grafana Tempo trace data:

• Required parameters:
  • query: Tempo query string (e.g., {service.name="frontend"}, {duration>1s})
• Optional parameters:
  • url: The Tempo server URL (default: from TEMPO_URL environment variable or http://localhost:3200)
  • start: Start time for the query (default: 1h ago)
  • end: End time for the query (default: now)
  • limit: Maximum number of traces to return (default: 20)
  • username: Username for basic authentication (optional)
  • password: Password for basic authentication (optional)
  • token: Bearer token for authentication (optional)

Environment Variables

The Tempo query tool supports the following environment variables:

• TEMPO_URL: Default Tempo server URL to use if not specified in the request
• SSE_PORT: Port for the HTTP/SSE server (default: 8080)

Testing

./run-client.sh tempo_query "{resource.service.name=\\\"example-service\\\"}"

Using with Claude Desktop

You can use this MCP server with Claude Desktop to add Tempo query tools. Follow these steps:

1. Build the server or Docker image
2. Configure Claude Desktop to use the server by adding it to your Claude Desktop configuration file

Example Claude Desktop configuration:

{
  "mcpServers": {
    "temposerver": {
      "command": "path/to/tempo-mcp-server",
      "args": [],
      "env": {
        "TEMPO_URL": "http://localhost:3200"
      },
      "disabled": false,
      "autoApprove": ["tempo_query"]
    }
  }
}

For Docker:

{
  "mcpServers": {
    "temposerver": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "-e", "TEMPO_URL=http://host.docker.internal:3200", "tempo-mcp-server"],
      "disabled": false,
      "autoApprove": ["tempo_query"]
    }
  }
}

The Claude Desktop configuration file is located at:

• On macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• On Windows: %APPDATA%\Claude\claude_desktop_config.json
• On Linux: ~/.config/Claude/claude_desktop_config.json

Using with Cursor

You can also integrate the Tempo MCP server with the Cursor editor. To do this, add the following configuration to your Cursor settings:

{
  "mcpServers": {
    "tempo-mcp-server": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "-e", "TEMPO_URL=http://host.docker.internal:3200", "tempo-mcp-server:latest"]
    }
  }
}

Using with n8n

To use the Tempo MCP server with n8n, you can connect to it using the MCP Client Tool node:

1. Add an MCP Client Tool node to your n8n workflow

2. Configure the node with these parameters:

   • SSE Endpoint: http://your-server-address:8080/sse (replace with your actual server address)
   • Authentication: Choose appropriate authentication if needed
   • Tools to Include: Choose which Tempo tools to expose to the AI Agent

3. Connect the MCP Client Tool node to an AI Agent node that will use the Tempo querying capabilities

Example workflow: Trigger → MCP Client Tool (Tempo server) → AI Agent (Claude)

Example Usage

Once configured, you can use the tools in Claude with queries like:

• "Query Tempo for traces with the query {duration>1s}"
• "Find traces from the frontend service in Tempo using query {service.name=\"frontend\"}"
• "Show me the most recent 50 traces from Tempo with {http.status_code=500}"

License

This project is licensed under the MIT License.