Grafana
About
Access and manage Grafana resources, including dashboards, datasources, Prometheus, Loki, and alerting.
Details
- Author
- kis9a
- Categories
- Developer Tools, Other, Infrastructure
Jump to
Setup
Install Grafana in your MCP client (Claude Desktop, Cursor, Windsurf, and others).
Repository: https://github.com/kis9a/mcp-grafana-with-questdb
Follow the installation instructions in the repository README, then restart your MCP client.
This repository is a fork of the original Grafana MCP server.
It includes custom modifications listed below.
- Added support for a new tool:QuestDB
- Introducedquestdbflag to enable/disable
- Addedtools/questdb.goimplementing the QuestDB query logic
- Introducedathenaflag to enable/disable
- Addedtools/athena.goimplementing the Athena query logic
AModel Context Protocol(MCP) server for Grafana.
This provides access to your Grafana instance and the surrounding ecosystem.
The following features are currently available in MCP server. This list is for informational purposes only and does not represent a roadmap or commitment to future features.
- Search for dashboards:Find dashboards by title or other metadata
- Get dashboard by UID:Retrieve full dashboard details using its unique identifier
- Update or create a dashboard:Modify existing dashboards or create new ones.Note: Use with caution due to context window limitations; seeissue #101
- Get panel queries and datasource info:Get the title, query string, and datasource information (including UID and type, if available) from every panel in a dashboard
- List and fetch datasource information:View all configured datasources and retrieve detailed information about each.
- Supported datasource types: Prometheus, Loki, QuestDB, Athena.
- Query Prometheus:Execute PromQL queries (supports both instant and range metric queries) against Prometheus datasources.
- Query Prometheus metadata:Retrieve metric metadata, metric names, label names, and label values from Prometheus datasources.
- Query Loki logs and metrics:Run both log queries and metric queries using LogQL against Loki datasources.
- Query Loki metadata:Retrieve label names, label values, and stream statistics from Loki datasources.
- Search, create, update, and close incidents:Manage incidents in Grafana Incident, including searching, creating, updating, and resolving incidents.
- Create Sift investigations:Start a new Sift investigation for analyzing logs or traces.
- List Sift investigations:Retrieve a list of Sift investigations, with support for a limit parameter.
- Get Sift investigation:Retrieve details of a specific Sift investigation by its UUID.
- Get Sift analyses:Retrieve a specific analysis from a Sift investigation.
- Find error patterns in logs:Detect elevated error patterns in Loki logs using Sift.
- Find slow requests:Detect slow requests using Sift (Tempo).
- List and fetch alert rule information:View alert rules and their statuses (firing/normal/error/etc.) in Grafana.
- List contact points:View configured notification contact points in Grafana.
- List and manage schedules:View and manage on-call schedules in Grafana OnCall.
- Get shift details:Retrieve detailed information about specific on-call shifts.
- Get current on-call users:See which users are currently on call for a schedule.
- List teams and users:View all OnCall teams and users.
- List teams:View all configured teams in Grafana.
The list of tools is configurable, so you can choose which tools you want to make available to the MCP client. This is useful if you don't use certain functionality or if you don't want to take up too much of the context window. To disable a category of tools, use the--disable-<category>flag when starting the server. For example, to disable the OnCall tools, use--disable-oncall.
-
Create a service account in Grafana with enough permissions to use the tools you want to use, generate a service account token, and copy it to the clipboard for use in the configuration file. Follow theGrafana documentationfor details.
You have several options to installmcp-grafana:
-
Docker image: Use the pre-built Docker image from Docker Hub.
Important: The Docker image's entrypoint is configured to run the MCP server in SSE mode by default, but most users will want to use STDIO mode for direct integration with AI assistants like Claude Desktop:
- STDIO Mode: For stdio mode you must explicitly override the default with-t stdioand include the-iflag to keep stdin open:
docker pull mcp/grafana docker run --rm -i -e GRAFANA_URL=http://localhost:3000 -e GRAFANA_API_KEY=<your service account token> mcp/grafana -t stdio
- SSE Mode: In this mode, the server runs as an HTTP server that clients connect to. You must expose port 8000 using the-pflag:
docker pull mcp/grafana docker run --rm -p 8000:8000 -e GRAFANA_URL=http://localhost:3000 -e GRAFANA_API_KEY=<your service account token> mcp/grafana
- Streamable HTTP Mode: In this mode, the server operates as an independent process that can handle multiple client connections. You must expose port 8000 using the-pflag: For this mode you must explicitly override the default with-t streamable-http
docker pull mcp/grafana docker run --rm -p 8000:8000 -e GRAFANA_URL=http://localhost:3000 -e GRAFANA_API_KEY=<your service account token> mcp/grafana -t streamable-http
Download binary: Download the latest release ofmcp-grafanafrom thereleases pageand place it in your$PATH.
Build from source: If you have a Go toolchain installed you can also build and install it from source, using theGOBINenvironment variable to specify the directory where the binary should be installed. This should also be in yourPATH.
GOBIN="$HOME/go/bin" go install github.com/grafana/mcp-grafana/cmd/mcp-grafana@latest
Add the server configuration to your client configuration file. For example, for Claude Desktop:
{ "mcpServers": { "grafana": { "command": "mcp-grafana", "args": [], "env": { "GRAFANA_URL": "http://localhost:3000", "GRAFANA_API_KEY": "<your service account token>" } } } }
Note: if you seeError: spawn mcp-grafana ENOENTin Claude Desktop, you need to specify the full path tomcp-grafana.
{ "mcpServers": { "grafana": { "command": "docker", "args": [ "run", "--rm", "-i", "-e", "GRAFANA_URL", "-e", "GRAFANA_API_KEY", "mcp/grafana", "-t", "stdio" ], "env": { "GRAFANA_URL": "http://localhost:3000", "GRAFANA_API_KEY": "<your service account token>" } } } }
Note: The-t stdioargument is essential here because it overrides the default SSE mode in the Docker image.
If you're using VSCode and running the MCP server in SSE mode (which is the default when using the Docker image without overriding the transport), make sure your.vscode/settings.jsonincludes the following:
"mcp": { "servers": { "grafana": { "type": "sse", "url": "http://localhost:8000/sse" } } }
You can enable debug mode for the Grafana transport by adding the-debugflag to the command. This will provide detailed logging of HTTP requests and responses between the MCP server and the Grafana API, which can be helpful for troubleshooting.
To use debug mode with the Claude Desktop configuration, update your config as follows:
{ "mcpServers": { "grafana": { "command": "mcp-grafana", "args": ["-debug"], "env": { "GRAFANA_URL": "http://localhost:3000", "GRAFANA_API_KEY": "<your service account token>" } } } }
{ "mcpServers": { "grafana": { "command": "docker", "args": [ "run", "--rm", "-i", "-e", "GRAFANA_URL", "-e", "GRAFANA_API_KEY", "mcp/grafana", "-t", "stdio", "-debug" ], "env": { "GRAFANA_URL": "http://localhost:3000", "GRAFANA_API_KEY": "<your service account token>" } } } }
Note: As with the standard configuration, the-t stdioargument is required to override the default SSE mode in the Docker image.
Contributions are welcome! Please open an issue or submit a pull request if you have any suggestions or improvements.
This project is written in Go. Install Go following the instructions for your platform.
To run the server locally in STDIO mode (which is the default for local development), use:
To run the server locally in SSE mode, use:
go run ./cmd/mcp-grafana --transport sse
You can also run the server using the SSE transport inside a custom built Docker image. Just like the published Docker image, this custom image's entrypoint defaults to SSE mode. To build the image, use:
And to run the image in SSE mode (the default), use:
docker run -it --rm -p 8000:8000 mcp-grafana:latest
If you need to run it in STDIO mode instead, override the transport setting:
docker run -it --rm mcp-grafana:latest -t stdio
There are three types of tests available:
- Unit Tests (no external dependencies required):
- Integration Tests (requires docker containers to be up and running):
- Cloud Tests (requires cloud Grafana instance and credentials):
Note: Cloud tests are automatically configured in CI. For local development, you'll need to set up your own Grafana Cloud instance and credentials.
More comprehensive integration tests will require a Grafana instance to be running locally on port 3000; you can start one with Docker Compose:
If you're adding more tools, please add integration tests for them. The existing tests should be a good starting point.
This includes a custom linter that checks for unescaped commas injsonschemastruct tags. The commas indescriptionfields must be escaped with\\,to prevent silent truncation. You can run just this linter with:
See theJSONSchema Linter documentationfor more details.
This project is licensed under theApache License, Version 2.0.
This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.
Access Grafana resources like dashboards, datasources, Prometheus, Loki, and alerts.
MCP server for Grafana — manage dashboards, datasources, alerts, folders, and annotations over stdio
A server for querying Loki logs from Grafana.
An MCP server for log analysis using the LogAI framework, with optional Grafana and GitHub integrations.
A Go-based server to query Grafana Loki logs using the Model Context Protocol (MCP).
Expose Prometheus monitoring tools to an LLM for querying and analysis.
An MCP server for querying Loki logs via logcli.
An MCP server for querying distributed tracing data from Grafana Tempo.
Interact with Honeycomb observability data using the Model Context Protocol.
Access Prometheus metrics and queries through standardized MCP interfaces.
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
