Skip to content
Back to search

mcp-victoriametrics

The implementation of Model Context Protocol (MCP) server for VictoriaMetrics

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/VictoriaMetrics/mcp-victoriametrics with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/VictoriaMetrics/mcp-victoriametrics'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/victoriametrics--mcp-victoriametrics/badge.svg)](/listings/victoriametrics--mcp-victoriametrics)

HTML

<a href="/listings/victoriametrics--mcp-victoriametrics"><img src="/api/listings/victoriametrics--mcp-victoriametrics/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Binaries

Just download the latest release from [Releases](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases) page and put it to your PATH.

Example for Linux x86_64 (note that other architectures and platforms are also available):

latest=$(curl -s https://api.github.com/repos/VictoriaMetrics/mcp-victoriametrics/releases/latest | grep 'tag_name' | cut -d\" -f4)
wget https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/download/$latest/mcp-victoriametrics_Linux_x86_64.tar.gz
tar axvf mcp-victoriametrics_Linux_x86_64.tar.gz

Docker

You can run VictoriaMetrics MCP Server using Docker.

This is the easiest way to get started without needing to install Go or build from source.

docker run -d --name mcp-victoriametrics \
  -e VM_INSTANCE_ENTRYPOINT=https://play.victoriametrics.com \
  -e VM_INSTANCE_TYPE=cluster \
  -e MCP_SERVER_MODE=sse \
  -e MCP_LISTEN_ADDR=:8080 \
  -p 8080:8080 \
  ghcr.io/victoriametrics/mcp-victoriametrics

You should replace environment variables with your own parameters.

Note that the `MCP_SERVER_MODE=http` flag is used to enable Streamable HTTP mode. More details about server modes can be found in the [Configuration](#configuration) section.

See available docker images in [github registry](https://github.com/orgs/VictoriaMetrics/packages/container/package/mcp-victoriametrics).

Also see [Using Docker instead of binary](#using-docker-instead-of-binary) section for more details about using Docker with MCP server with clients in stdio mode.

Source Code

For building binary from source code you can use the following approach:

- Clone repo:

  git clone https://github.com/VictoriaMetrics/mcp-victoriametrics.git
  cd mcp-victoriametrics

- Build binary from cloned source code:

  make build
  # after that you can find binary mcp-victoriametrics and copy this file to your PATH or run inplace

- Build image from cloned source code:

  docker build -t mcp-victoriametrics .
  # after that you can use docker image mcp-victoriametrics for running or pushing

Helm

Check out [VictoriaMetrics MCP Server Helm chart](https://docs.victoriametrics.com/helm/victoria-metrics-mcp/) documentation for more details about installation using Helm.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 870 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # <img width="25" height="25" alt="vm-community-icon" src="https://github.com/user-attachments/assets/1c060750-370a-4440-b619-78b78c7abd7a" /> VictoriaMetrics MCP Server
  2. [![Latest Release](https://img.shields.io/github/v/release/VictoriaMetrics/mcp-victoriametrics?sort=semver&label=&filter=!*-victorialogs&logo=github&labelColor=gray&color=gray&link=https%3A%2F%2Fgithub.com%2FVictoriaMetrics%2Fmcp-victoriametrics%2Freleases%2Flatest)](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases)
  3. [![Trust Score](https://archestra.ai/mcp-catalog/api/badge/quality/VictoriaMetrics/mcp-victoriametrics)](https://archestra.ai/mcp-catalog/victoriametrics-community__mcp-victoriametrics)
  4. ![License](https://img.shields.io/github/license/VictoriaMetrics/mcp-victoriametrics?labelColor=green&label=&link=https%3A%2F%2Fgithub.com%2FVictoriaMetrics%2Fmcp-victoriametrics%2Fblob%2Fmain%2FLICENSE)
  5. ![Slack](https://img.shields.io/badge/Join-4A154B?logo=slack&link=https%3A%2F%2Fslack.victoriametrics.com)
  6. ![X](https://img.shields.io/twitter/follow/VictoriaMetrics?style=flat&label=Follow&color=black&logo=x&labelColor=black&link=https%3A%2F%2Fx.com%2FVictoriaMetrics)
  7. ![Reddit](https://img.shields.io/reddit/subreddit-subscribers/VictoriaMetrics?style=flat&label=Join&labelColor=red&logoColor=white&logo=reddit&link=https%3A%2F%2Fwww.reddit.com%2Fr%2FVictoriaMetrics)
  8. The implementation of [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server for [VictoriaMetrics](https://docs.victoriametrics.com/victoriametrics/).
  9. This provides access to your VictoriaMetrics instance and seamless integration with [VictoriaMetrics APIs](https://docs.victoriametrics.com/victoriametrics/url-examples/) and [documentation](https://docs.victoriametrics.com/).
  10. It can give you a comprehensive interface for monitoring, observability, and debugging tasks related to your VictoriaMetrics instances, enable advanced automation and interaction capabilities for engineers and tools.
  11. ## Features
  12. This MCP server allows you to use almost all read-only APIs of VictoriaMetrics, i.e. all functions available in [VMUI](https://docs.victoriametrics.com/#vmui):
  13. - Querying metrics and exploring data (even drawing graphs if your client supports it)
  14. - Listing and exporting available metrics, labels, labels values and entire series
  15. - Analyzing and testing your alerting and recording rules and alerts
  16. - Showing parameters of your VictoriaMetrics instance
  17. - Exploring cardinality of your data and metrics usage statistics
  18. - Analyzing, tracing, prettifying and explaining your queries
  19. - Debugging your relabeling rules, downsampling and retention policy configurations
  20. - Integration with [VictoriaMetrics Cloud](https://docs.victoriametrics.com/victoriametrics-cloud/)
  21. - UI with setup instrinctions and tools inspection on the root endpoint (only in Streamable HTTP mode)
  22. In addition, the MCP server contains embedded up-to-date documentation and is able to search it without online access.
  23. ![image](./ui.png)
  24. More details about the exact available tools and prompts can be found in the [Usage](#usage) section.
  25. You can combine functionality of tools, docs search in your prompts and invent great usage scenarios for your VictoriaMetrics instance.
  26. Just check the [Dialog example](#dialog-example) section to see how it can work.
  27. And please note the fact that the quality of the MCP Server and its responses depends very much on the capabilities of your client and the quality of the model you are using.
  28. You can also combine the MCP server with other observability or doc search related MCP Servers and get even more powerful results.
  29. ## Try without installation
  30. There is a publicly available instance of the VictoriaMetrics MCP Server that you can use to test the features without installing it:
  31. ```
  32. https://play-mcp.victoriametrics.com/mcp
  33. ```
  34. **Attention!** This URL is not supposed to be opened in a browser, it is intended to be used in MCP clients.
  35. It's available in [Streamable HTTP](#modes) mode and configured to work with [Public VictoriaMetrics Playground](https://play.victoriametrics.com).
  36. Here is example of configuration for [Claude Desktop](https://claude.ai/download):
  37. ![image](https://github.com/user-attachments/assets/b9cca3ff-f4c3-47bc-aac7-9359f12e858e)
  38. ## Requirements
  39. - [VictoriaMetrics](https://docs.victoriametrics.com/victoriametrics/) or [VictoriaMetrics Cloud](https://docs.victoriametrics.com/victoriametrics-cloud/) instance ([single-node](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/) or [cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/))
  40. - Go 1.26 or higher (if you want to build from source)
  41. ## Installation
  42. ### Binaries
  43. Just download the latest release from [Releases](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases) page and put it to your PATH.
  44. Example for Linux x86_64 (note that other architectures and platforms are also available):
  45. ```bash
  46. latest=$(curl -s https://api.github.com/repos/VictoriaMetrics/mcp-victoriametrics/releases/latest | grep 'tag_name' | cut -d\" -f4)
  47. wget https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/download/$latest/mcp-victoriametrics_Linux_x86_64.tar.gz
  48. tar axvf mcp-victoriametrics_Linux_x86_64.tar.gz
  49. ```
  50. ### Docker
  51. You can run VictoriaMetrics MCP Server using Docker.
  52. This is the easiest way to get started without needing to install Go or build from source.
  53. ```bash
  54. docker run -d --name mcp-victoriametrics \
  55. -e VM_INSTANCE_ENTRYPOINT=https://play.victoriametrics.com \
  56. -e VM_INSTANCE_TYPE=cluster \
  57. -e MCP_SERVER_MODE=sse \
  58. -e MCP_LISTEN_ADDR=:8080 \
  59. -e MCP_AUTH_TOKEN=your-secret-token \
  60. -p 8080:8080 \
  61. ghcr.io/victoriametrics/mcp-victoriametrics
  62. ```
  63. You should replace environment variables with your own parameters.
  64. Note that the `MCP_SERVER_MODE=http` flag is used to enable Streamable HTTP mode.
  65. More details about server modes can be found in the [Configuration](#configuration) section.
  66. See available docker images in [github registry](https://github.com/orgs/VictoriaMetrics/packages/container/package/mcp-victoriametrics).
  67. Also see [Using Docker instead of binary](#using-docker-instead-of-binary) section for more details about using Docker with MCP server with clients in stdio mode.
  68. ### Source Code
  69. For building binary from source code you can use the following approach:
  70. - Clone repo:
  71. ```bash
  72. git clone https://github.com/VictoriaMetrics/mcp-victoriametrics.git
  73. cd mcp-victoriametrics
  74. ```
  75. - Build binary from cloned source code:
  76. ```bash
  77. make build
  78. # after that you can find binary mcp-victoriametrics and copy this file to your PATH or run inplace
  79. ```
  80. - Build image from cloned source code:
  81. ```bash
  82. docker build -t mcp-victoriametrics .
  83. # after that you can use docker image mcp-victoriametrics for running or pushing
  84. ```
  85. ### Helm
  86. Check out [VictoriaMetrics MCP Server Helm chart](https://docs.victoriametrics.com/helm/victoria-metrics-mcp/) documentation for more details about installation using Helm.
  87. ## Configuration
  88. MCP Server for VictoriaMetrics is configured via environment variables:
  89. | Variable | Description | Required | Default | Allowed values |
  90. |------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------|---------------------------------------------------------------------------------------------------|------------------------|
  91. | `VM_INSTANCE_ENTRYPOINT` / `VMC_API_KEY` | URL to VictoriaMetrics instance (it should be root `/` URL of vmsingle or vmselect) | Yes (if you don't use `VMC_API_KEY`) | - | - |
  92. | `VM_INSTANCE_TYPE` | Type of VictoriaMetrics instance | Yes (if you don't use ``VMC_API_KEY``) | - | `single`, `cluster` |
  93. | `VM_INSTANCE_BEARER_TOKEN` | Authentication token for VictoriaMetrics API | No | - | - |
  94. | `VM_INSTANCE_HEADERS` | Custom HTTP headers to send with requests (comma-separated key=value pairs) | No | - | - |
  95. | `MCP_PASSTHROUGH_HEADERS` | HTTP header names to forward from incoming MCP requests to VictoriaMetrics (comma-separated list). Overrides `VM_INSTANCE_HEADERS` on collision. Only applies in `sse`/`http` modes. | No | - | - |
  96. | `VM_DEFAULT_TENANT_ID` | Default tenant ID for cluster mode. Format: `accountID` or `accountID:projectID` (32-bit integers). See [VictoriaMetrics cluster docs](https://docs.victoriametrics.com/cluster-victoriametrics/#multitenancy) | No | `0` | - |
  97. | `VMC_API_KEY` | [API key from VictoriaMetrics Cloud Console](https://docs.victoriametrics.com/victoriametrics-cloud/api/) | No | - | - |
  98. | `MCP_SERVER_MODE` | Server operation mode. See [Modes](#modes) for details. | No | `stdio` | `stdio`, `sse`, `http` |
  99. | `MCP_LISTEN_ADDR` | Address for SSE or HTTP server to listen on | No | `localhost:8080` | - |
  100. | `MCP_DISABLED_TOOLS` | Comma-separated list of tools to disable | No | 'export,flags,metric_relabel_debug,downsampling_filters_debug,retention_filters_debug,test_rules' | - |
  101. | `MCP_DISABLE_RESOURCES` | Disable all resources (documentation tool will continue to work) | No | `false` | `false`, `true` |
  102. | `MCP_HEARTBEAT_INTERVAL` | Defines the heartbeat interval for the streamable-http protocol. <br /> It means the MCP server will send a heartbeat to the client through the GET connection, <br /> to keep the connection alive from being closed by the network infrastructure (e.g. gateways) | No | `30s` | - |
  103. | `MCP_STATELESS` | Run the Streamable HTTP server in stateless mode (`http` mode only). Session IDs are ignored instead of validated, so the server does not reject an `Mcp-Session-Id` injected by a fronting platform. Required when hosting behind a proxy that manages sessions for you (e.g. AWS Bedrock AgentCore Runtime). | No | `false` | `false`, `true` |
  104. | `MCP_DISABLE_LOCALHOST_PROTECTION` | Disable the Streamable HTTP DNS-rebinding guard (`http` mode only), which otherwise rejects (`403`) any loopback request whose `Host` header is not a localhost value. Set `true` only behind a same-host reverse proxy that forwards over `127.0.0.1` while preserving the original `Host` header (e.g. AWS Bedrock AgentCore Runtime). | No | `false` | `false`, `true` |
  105. | `MCP_MAX_RESPONSE_SIZE` | Maximum size in bytes of a VictoriaMetrics response that a tool reads. A larger response is returned as a tool error instead of being read in full. `0` disables the limit. | No | `16777216` | - |
  106. | `MCP_INSTRUCTIONS_OVERRIDE` | Text that fully replaces the default MCP server instructions sent to clients. Useful for tailoring the server to a particular instance (environment, tenants, naming conventions, etc.) | No | - | - |
  107. | `MCP_AUTH_TOKEN` | Bearer token for authenticating incoming MCP requests (only applies in `sse`/`http` modes). Public paths (`/health/*`, `/metrics`, `/`, static assets) are excluded from authentication. | No | - | - |
  108. | `MCP_LOG_FORMAT` | Log output format | No | `text` | `text`, `json` |
  109. | `MCP_LOG_LEVEL` | Minimum log level. `debug` also logs MCP request and result payloads | No | `info` | `debug`, `info`, `warn`, `error` |
  110. You can use two options to connect to your VictoriaMetrics instance:
  111. - Using `VM_INSTANCE_ENTRYPOINT` + `VM_INSTANCE_TYPE` + `VM_INSTANCE_BEARER_TOKEN` (optional) environment variables to connect to any single-node or cluster instance of VictoriaMetrics.
  112. - Using `VMC_API_KEY` environment variable to work with your [VictoriaMetrics Cloud](https://victoriametrics.com/products/cloud/) instances.
  113. ### Modes
  114. MCP Server supports the following modes of operation (transports):
  115. - `stdio` - Standard input/output mode, where the server reads commands from standard input and writes responses to standard output. This is the default mode and is suitable for local servers.
  116. - `sse` - Server-Sent Events. Server will expose the `/sse` and `/message` endpoints for SSE connections.
  117. - `http` - Streamable HTTP. Server will expose the `/mcp` endpoint for HTTP connections.
  118. > **Hosting `http` mode behind a reverse proxy (e.g. AWS Bedrock AgentCore Runtime).**
  119. > A platform that terminates MCP for you and forwards requests to this server over
  120. > loopback — injecting its own `Mcp-Session-Id` and preserving the original (non-localhost)
  121. > `Host` header — needs two toggles, otherwise tool discovery fails (the server crash-loops
  122. > on session rejection, or returns `403` from the DNS-rebinding guard): set
  123. > `MCP_STATELESS=true` and `MCP_DISABLE_LOCALHOST_PROTECTION=true` alongside
  124. > `MCP_SERVER_MODE=http`. Leave both off for direct/local use.
  125. More info about traqnsports you can find in MCP docs:
  126. - [Core concepts -> Transports](https://modelcontextprotocol.io/docs/concepts/transports)
  127. - [Specifications -> Transports](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports)
  128. ### Сonfiguration examples
  129. ```bash
  130. # For a single-node instance
  131. export VM_INSTANCE_ENTRYPOINT="http://localhost:8428"
  132. export VM_INSTANCE_TYPE="single"
  133. export VM_INSTANCE_BEARER_TOKEN="your-token"
  134. export MCP_PASSTHROUGH_HEADERS="X-Token,X-Access-Key"
  135. # For a cluster
  136. export VM_INSTANCE_ENTRYPOINT="https://play.victoriametrics.com"
  137. export VM_INSTANCE_TYPE="cluster"
  138. export MCP_DISABLED_TOOLS="export,metric_statistics,test_rules" # disable export, statistics and rules unit test tools
  139. # For VictoriaMetrics Cloud
  140. export VMC_API_KEY="<you-api-key>"
  141. # Server mode
  142. export MCP_SERVER_MODE="sse"
  143. export MCP_LISTEN_ADDR="0.0.0.0:8080"
  144. # Authentication (optional, only for sse/http modes)
  145. export MCP_AUTH_TOKEN="your-secret-token"
  146. # Custom headers for authentication (e.g., behind a reverse proxy)
  147. # Expected syntax is key=value separated by commas
  148. export VM_INSTANCE_HEADERS="<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  149. ```
  150. ## Endpoints
  151. In SSE and HTTP modes the MCP server provides the following endpoints:
  152. | Endpoint | Description |
  153. |----------------------|--------------------------------------------------------------------------------------------------|
  154. | `/` | Landing page with setup help and tool inspection |
  155. | `/sse` + `/message` | Endpoints for messages in SSE mode (for MCP clients that support SSE) |
  156. | `/mcp` | HTTP endpoint for streaming messages in HTTP mode (for MCP clients that support Streamable HTTP) |
  157. | `/metrics` | Metrics in Prometheus format for monitoring the MCP server |
  158. | `/health/liveness` | Liveness check endpoint to ensure the server is running |
  159. | `/health/readiness` | Readiness check endpoint to ensure the server is ready to accept requests |
  160. ## Setup in clients
  161. <!-- clients:start -->
  162. <!-- Generated from web/src/clients.yaml by `make update-readme`, do not edit manually. -->
  163. ### Claude Desktop
  164. Add this to your Claude Desktop `claude_desktop_config.json` file (you can find it if open `Settings` -> `Developer` -> `Edit config`):
  165. ```json
  166. {
  167. "mcpServers": {
  168. "victoriametrics": {
  169. "command": "/path/to/mcp-victoriametrics",
  170. "env": {
  171. "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
  172. "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
  173. "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
  174. "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  175. }
  176. }
  177. }
  178. }
  179. ```
  180. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  181. ```json
  182. {
  183. "mcpServers": {
  184. "victoriametrics": {
  185. "command": "npx",
  186. "args": ["-y", "mcp-remote", "http://localhost:8080/mcp"]
  187. }
  188. }
  189. }
  190. ```
  191. See [Claude Desktop MCP docs](https://modelcontextprotocol.io/quickstart/user) for more info.
  192. ### Claude Code
  193. Run the command:
  194. ```sh
  195. claude mcp add victoriametrics \
  196. -e VM_INSTANCE_ENTRYPOINT=<YOUR_VM_INSTANCE> \
  197. -e VM_INSTANCE_TYPE=<YOUR_VM_INSTANCE_TYPE> \
  198. -e VM_INSTANCE_BEARER_TOKEN=<YOUR_VM_BEARER_TOKEN> \
  199. -e VM_INSTANCE_HEADERS="<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>" \
  200. -- /path/to/mcp-victoriametrics
  201. ```
  202. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  203. ```sh
  204. claude mcp add victoriametrics --transport http http://localhost:8080/mcp
  205. ```
  206. See [Claude Code MCP docs](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/tutorials#set-up-model-context-protocol-mcp) for more info.
  207. ### Cursor
  208. Go to: `Settings` -> `Cursor Settings` -> `MCP` -> `Add new global MCP server` and paste the following configuration into your Cursor `~/.cursor/mcp.json` file:
  209. ```json
  210. {
  211. "mcpServers": {
  212. "victoriametrics": {
  213. "command": "/path/to/mcp-victoriametrics",
  214. "env": {
  215. "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
  216. "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
  217. "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
  218. "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  219. }
  220. }
  221. }
  222. }
  223. ```
  224. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  225. ```json
  226. {
  227. "mcpServers": {
  228. "victoriametrics": {
  229. "url": "http://localhost:8080/mcp"
  230. }
  231. }
  232. }
  233. ```
  234. See [Cursor MCP docs](https://docs.cursor.com/context/model-context-protocol) for more info.
  235. ### Codex
  236. Codex CLI and the IDE extension use the same MCP configuration file: `~/.codex/config.toml`
  237. (or `.codex/config.toml` in a trusted project).
  238. Run the command:
  239. ```sh
  240. codex mcp add victoriametrics \
  241. --env VM_INSTANCE_ENTRYPOINT=<YOUR_VM_INSTANCE> \
  242. --env VM_INSTANCE_TYPE=<YOUR_VM_INSTANCE_TYPE> \
  243. --env VM_INSTANCE_BEARER_TOKEN=<YOUR_VM_BEARER_TOKEN> \
  244. --env VM_INSTANCE_HEADERS="<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>" \
  245. -- /path/to/mcp-victoriametrics
  246. ```
  247. Or add the following to your Codex `~/.codex/config.toml` file:
  248. ```toml
  249. [mcp_servers.victoriametrics]
  250. command = "/path/to/mcp-victoriametrics"
  251. [mcp_servers.victoriametrics.env]
  252. VM_INSTANCE_ENTRYPOINT = "<YOUR_VM_INSTANCE>"
  253. VM_INSTANCE_TYPE = "<YOUR_VM_INSTANCE_TYPE>"
  254. VM_INSTANCE_BEARER_TOKEN = "<YOUR_VM_BEARER_TOKEN>"
  255. VM_INSTANCE_HEADERS = "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  256. ```
  257. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  258. ```sh
  259. codex mcp add victoriametrics --url http://localhost:8080/mcp
  260. ```
  261. See [Codex MCP docs](https://developers.openai.com/codex/mcp) for more info.
  262. ### Visual Studio Code
  263. Add this to your VS Code MCP config file:
  264. ```json
  265. {
  266. "servers": {
  267. "victoriametrics": {
  268. "type": "stdio",
  269. "command": "/path/to/mcp-victoriametrics",
  270. "env": {
  271. "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
  272. "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
  273. "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
  274. "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  275. }
  276. }
  277. }
  278. }
  279. ```
  280. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  281. ```json
  282. {
  283. "servers": {
  284. "victoriametrics": {
  285. "type": "http",
  286. "url": "http://localhost:8080/mcp"
  287. }
  288. }
  289. }
  290. ```
  291. See [Visual Studio Code MCP docs](https://code.visualstudio.com/docs/copilot/chat/mcp-servers) for more info.
  292. ### Zed
  293. Add the following to your Zed config file:
  294. ```json
  295. "context_servers": {
  296. "victoriametrics": {
  297. "command": {
  298. "path": "/path/to/mcp-victoriametrics",
  299. "args": [],
  300. "env": {
  301. "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
  302. "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
  303. "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
  304. "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  305. }
  306. },
  307. "settings": {}
  308. }
  309. }
  310. ```
  311. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  312. ```json
  313. {
  314. "context_servers": {
  315. "victoriametrics": {
  316. "url": "http://localhost:8080/mcp"
  317. }
  318. }
  319. }
  320. ```
  321. See [Zed MCP docs](https://zed.dev/docs/ai/mcp) for more info.
  322. ### JetBrains IDEs
  323. - Open `Settings` -> `Tools` -> `AI Assistant` -> `Model Context Protocol (MCP)`.
  324. - Click `Add (+)`
  325. - Select `As JSON`
  326. - Put the following to the input field:
  327. ```json
  328. {
  329. "mcpServers": {
  330. "victoriametrics": {
  331. "command": "/path/to/mcp-victoriametrics",
  332. "env": {
  333. "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
  334. "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
  335. "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
  336. "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  337. }
  338. }
  339. }
  340. }
  341. ```
  342. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  343. ```json
  344. {
  345. "mcpServers": {
  346. "victoriametrics": {
  347. "url": "http://localhost:8080/mcp"
  348. }
  349. }
  350. }
  351. ```
  352. ### Windsurf
  353. Add the following to your Windsurf MCP config file:
  354. ```json
  355. {
  356. "mcpServers": {
  357. "victoriametrics": {
  358. "command": "/path/to/mcp-victoriametrics",
  359. "env": {
  360. "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
  361. "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
  362. "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
  363. "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  364. }
  365. }
  366. }
  367. }
  368. ```
  369. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  370. ```json
  371. {
  372. "mcpServers": {
  373. "victoriametrics": {
  374. "serverUrl": "http://localhost:8080/mcp"
  375. }
  376. }
  377. }
  378. ```
  379. See [Windsurf MCP docs](https://docs.windsurf.com/windsurf/mcp) for more info.
  380. ### Gemini CLI
  381. Add the following to your Gemini CLI `~/.gemini/settings.json` file:
  382. ```json
  383. {
  384. "mcpServers": {
  385. "victoriametrics": {
  386. "command": "/path/to/mcp-victoriametrics",
  387. "env": {
  388. "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
  389. "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
  390. "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
  391. "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  392. }
  393. }
  394. }
  395. }
  396. ```
  397. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  398. ```sh
  399. gemini mcp add victoriametrics --transport http http://localhost:8080/mcp
  400. ```
  401. See [Gemini CLI MCP docs](https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md) for more info.
  402. ### OpenCode
  403. Add the following to your OpenCode config file in `~/.config/opencode/opencode.json`:
  404. ```json
  405. {
  406. "mcp": {
  407. "victoriametrics": {
  408. "type": "local",
  409. "command": ["/path/to/mcp-victoriametrics"],
  410. "enabled": true,
  411. "environment": {
  412. "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
  413. "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
  414. "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
  415. "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  416. }
  417. }
  418. }
  419. }
  420. ```
  421. To connect to a server running in [Streamable HTTP](#modes) mode at `http://localhost:8080`:
  422. ```json
  423. {
  424. "mcp": {
  425. "victoriametrics": {
  426. "type": "remote",
  427. "url": "http://localhost:8080/mcp"
  428. }
  429. }
  430. }
  431. ```
  432. See [OpenCode MCP docs](https://opencode.ai/docs/mcp-servers/) for more info.
  433. <!-- clients:end -->
  434. ### Using Docker instead of binary
  435. You can run VictoriaMetrics MCP server using Docker instead of local binary.
  436. You should replace run command in configuration examples above in the following way:
  437. ```
  438. {
  439. "mcpServers": {
  440. "victoriametrics": {
  441. "command": "docker",
  442. "args": [
  443. "run",
  444. "-i", "--rm",
  445. "-e", "VM_INSTANCE_ENTRYPOINT",
  446. "-e", "VM_INSTANCE_TYPE",
  447. "-e", "VM_INSTANCE_BEARER_TOKEN",
  448. "-e", "VM_INSTANCE_HEADERS",
  449. "ghcr.io/victoriametrics/mcp-victoriametrics",
  450. ],
  451. "env": {
  452. "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
  453. "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
  454. "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
  455. "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  456. }
  457. }
  458. }
  459. }
  460. ```
  461. ## Usage
  462. After [installing](#installation) and [configuring](#setup-in-clients) the MCP server, you can start using it with your favorite MCP client.
  463. You can start dialog with AI assistant from the phrase:
  464. ```
  465. Use MCP VictoriaMetrics in the following answers
  466. ```
  467. But it's not required, you can just start asking questions and the assistant will automatically use the tools and documentation to provide you with the best answers.
  468. Just take a look into [Dialog example](#dialog-example) section for better understanding what you can do with it.
  469. ### Tools and prompts
  470. MCP Server provides numerous tools for interacting with your VictoriaMetrics instance and pre-defined prompts for common tasks.
  471. <!-- tools:start -->
  472. <!-- Generated by `make update-readme`, do not edit manually. -->
  473. Tools:
  474. | Tool | Description | Enabled by default |
  475. |------------------------------|--------------------------------------------------------|:------------------:|
  476. | `active_queries` | Active queries | ✅ |
  477. | `alerts` | List of alerts | ✅ |
  478. | `documentation` | Search documentation resources | ✅ |
  479. | `downsampling_filters_debug` | Downsampling filters debugger | ❌ |
  480. | `explain_query` | Explain Query | ✅ |
  481. | `export` | Export time series | ❌ |
  482. | `flags` | List of non-default flags (parameters) | ❌ |
  483. | `label_values` | List of label values | ✅ |
  484. | `labels` | List of label names | ✅ |
  485. | `metric_relabel_debug` | Metric relabel debugger | ❌ |
  486. | `metric_statistics` | Metric statistics | ✅ |
  487. | `metrics` | List of metric names | ✅ |
  488. | `metrics_metadata` | List of metrics metadata (name, type, help and unit) | ✅ |
  489. | `prettify_query` | Prettify Query | ✅ |
  490. | `query` | Instant Query | ✅ |
  491. | `query_range` | Range Query | ✅ |
  492. | `retention_filters_debug` | Retention filters debugger | ❌ |
  493. | `rules` | List of alerting and recording rules | ✅ |
  494. | `series` | List of time series | ✅ |
  495. | `tenants` | List of tenants (cluster mode only) | ✅ |
  496. | `test_rules` | Unit test rules | ❌ |
  497. | `top_queries` | Top queries | ✅ |
  498. | `tsdb_status` | TSDB Stats (information about cardinality of the data) | ✅ |
  499. Prompts:
  500. | Prompt | Description |
  501. |---------------------------------------------|---------------------------------------------------------------------------------------|
  502. | `documentation` | Search by VictoriaMetrics documentation or give context for answering questions |
  503. | `rarely_used_metrics_with_high_cardinality` | List of rarely used metrics with high cardinality in the VictoriaMetrics instance API |
  504. | `unused_metrics` | List of unused (never queried) metrics in the VictoriaMetrics instance API |
  505. #### VictoriaMetrics Cloud
  506. Additional tools available for [VictoriaMetrics Cloud](https://docs.victoriametrics.com/victoriametrics-cloud/) deployments (with `VMC_API_KEY` parameter).
  507. In this mode, tools working with data require the `deployment_id` parameter.
  508. | Tool | Description | Enabled by default |
  509. |-------------------|---------------------------------------------------|:------------------:|
  510. | `access_tokens` | List of deployment access tokens | ✅ |
  511. | `cloud_providers` | List of cloud providers | ✅ |
  512. | `deployments` | List of deployments | ✅ |
  513. | `regions` | List of regions | ✅ |
  514. | `rule_file` | Get rules file content | ✅ |
  515. | `rule_filenames` | List of filenames of alerting and recording rules | ✅ |
  516. | `tiers` | List of tiers | ✅ |
  517. <!-- tools:end -->
  518. ## Dialog example
  519. Here is an example of a real dialog with the Assistant using the MCP Server with Claude Desktop, configured to work with the [public playground instance](https://play.victoriametrics.com). It shows how the server can help in practice.
  520. **👤 You:** What tenants are available in my VM?
  521. > 🤖 In your VictoriaMetrics instance, the following tenants are available `0:0` (default tenant), `1:0`, `10:0`, `100:0`
  522. **👤 You:** From now on, please use only default tenant
  523. > 🤖 I understand. From now on, I'll use only the default tenant (0:0) for all operations with your VictoriaMetrics instance.
  524. **👤 You:** Which metrics do we have?
  525. > 🤖 There are many metrics available in your VictoriaMetrics instance. The list includes metrics from various systems and components, such as:
  526. >
  527. > - System metrics (`node_`, `machine_`, etc.),
  528. > - Kubernetes metrics (`kube_`, `container_`, `apiserver_`, etc.),
  529. > - VictoriaMetrics-specific metrics (`vm_`, `vmagent_`, `vmalert_`, etc.),
  530. > - Go runtime metrics (`go_`),
  531. > - Prometheus-related metrics (`scrape_`, `promhttp_`),
  532. > - Various application metrics (`argocd_`, `alertmanager_`).
  533. >
  534. > This is a comprehensive list of over 2000 metrics that are available for querying. Is there a specific type of metric you're interested in exploring further?
  535. **👤 You:** Ok, let's work with kubernetes metrics from now on. Please show me which of these metrics never queried?
  536. > 🤖 Based on the results, I can see that there are two Kubernetes metrics that have never been queried (query count is 0):
  537. >
  538. > - `kube_persistentvolumeclaim_deletion_timestamp` - This metric provides information about when PersistentVolumeClaims were marked for deletion.
  539. > - `kube_pod_init_container_status_last_terminated_reason` - This metric shows the reason why init containers in pods were last terminated.
  540. >
  541. > These metrics might be valuable for monitoring and troubleshooting purposes:
  542. >
  543. > - The PVC deletion timestamp metric could help track deletion patterns or identify stuck PVCs.
  544. > - The init container termination reason metric could help identify common failure patterns in your initialization containers.
  545. >
  546. > Would you like me to explain more about what these metrics track or suggest some useful queries to start monitoring them?
  547. **👤 You:** Yes, please. And also, can you create relabeling rules to stop ingesting these metrics?
  548. > 🤖 I'll create a relabel configuration to exclude these never-queried metrics from collection. This will help reduce storage and processing overhead. Here's the relabel configuration you can add to your VictoriaMetrics scrape configuration:
  549. >
  550. > ```yaml
  551. > relabel_configs:
  552. > - action: drop
  553. > source_labels: [__name__]
  554. > regex: kube_persistentvolumeclaim_deletion_timestamp|kube_pod_init_container_status_last_terminated_reason
  555. > ```
  556. >
  557. > This configuration will:
  558. > 1. Look at each metric's name (the `__name__` label)
  559. > 2. Check if it matches either of the specified metrics
  560. > 3. Drop the metrics that match, preventing them from being collected and stored
  561. >
  562. > You can add this to your VictoriaMetrics configuration file or to the relevant scrape job configurations in your Prometheus configuration if you're using Prometheus as a scraper for VictoriaMetrics.
  563. > If you want to test this relabel configuration before implementing it, you can use the metric relabel debug tool to see how it would affect your metrics.
  564. **👤 You:** Yes, please debug this relabel config on real time series to see how it would affect my metrics
  565. > 🤖 Perfect! The relabel config works as expected:
  566. >
  567. > - The first two test cases show that both `kube_persistentvolumeclaim_deletion_timestamp` and `kube_pod_init_container_status_last_terminated_reason` metrics are correctly dropped (resulting labels are empty `{}`).
  568. > - The third test case confirms that other metrics like `kube_pod_status_phase` are preserved and not affected by our drop rule.
  569. >
  570. > You can confidently add this relabel configuration to your VictoriaMetrics or Prometheus configuration to stop collecting these unused metrics. This will save storage space and reduce processing overhead without affecting your current monitoring capabilities.
  571. **👤 You:** But i'm using vmagent resource of VictoriaMetrics operator, could you please give me part of specification for my agent with this relabel config?
  572. > 🤖 You're right, since you're using the VictoriaMetrics Operator and the VMAgent custom resource, the configuration needs to be in the appropriate format for that CR. Here's how you can add the relabel configuration to your VMAgent specification:
  573. >
  574. > ```yaml
  575. > apiVersion: operator.victoriametrics.com/v1beta1
  576. > kind: VMAgent
  577. > metadata:
  578. > name: your-vmagent-name
  579. > spec:
  580. > # ... your existing configuration ...
  581. >
  582. > # Add this section to configure global metric relabeling
  583. > inlineRelabelConfig:
  584. > - action: drop
  585. > sourceLabels: ["__name__"]
  586. > regex: kube_persistentvolumeclaim_deletion_timestamp|kube_pod_init_container_status_last_terminated_reason
  587. >
  588. > # ... rest of your configuration ...
  589. > ```
  590. >
  591. > Key points:
  592. >
  593. > - In the VMAgent spec, you use `inlineRelabelConfig` for inline relabeling rules
  594. > - The field is called `sourceLabels` (not `source_labels` as in Prometheus config)
  595. > - This is a global relabeling that will be applied to all metrics before they're stored
  596. **👤 You:** I decided not to remove those metrics, but just lower the sample rate for them using Downsampling. What downsampling parameters i have now?
  597. > 🤖 I can see that you currently have the following downsampling configuration:
  598. >
  599. > ```
  600. > -downsampling.period="7d:1m,30d:5m,180d:30m"
  601. > ```
  602. >
  603. > This means:
  604. >
  605. > - Data newer than 7 days is kept at its original resolution
  606. > - Data between 7-30 days old is downsampled to 1-minute resolution
  607. > - Data between 30-180 days old is downsampled to 5-minute resolution
  608. > - Data older than 180 days is downsampled to 30-minute resolution
  609. >
  610. > Now, if you want to add specific downsampling rules for those rarely-queried metrics, you can use the downsampling filters debug tool to test how new rules would work. Let's test a configuration where we apply more aggressive downsampling to those specific metrics:
  611. >
  612. > *...getting series and using downsampling filter debugger...*
  613. >
  614. > Great! Now our test is working correctly. Based on the current configuration and our testing, here's a suggested downsampling configuration for your VMAgent CR that would apply more aggressive downsampling to those rarely-queried metrics:
  615. >
  616. > ```yaml
  617. > apiVersion: operator.victoriametrics.com/v1beta1
  618. > kind: VMCluster
  619. > metadata:
  620. > name: monitoring-vm-cluster
  621. > spec:
  622. > # ... your existing configuration ...
  623. >
  624. > # Update the vmstorage section with the new downsampling parameters
  625. > vmstorage:
  626. > extraArgs:
  627. > downsampling.period: '{__name__=\"kube_persistentvolumeclaim_deletion_timestamp\"}:1d:10m,{__name__=\"kube_pod_init_container_status_last_terminated_reason\"}:1d:10m,7d:1m,30d:5m,180d:30m'
  628. >
  629. > # ... rest of your configuration ...
  630. > ```
  631. >
  632. > This configuration:
  633. >
  634. > - Applies 10-minute resolution downsampling for the rarely-queried metrics after just 1 day
  635. > - Maintains your existing downsampling policy for all other metrics
  636. >
  637. > The order of the downsampling rules is important - more specific rules should be listed first.
  638. During this dialog, the assistant was using the following tools:
  639. - `tenants` to get the list of available tenants
  640. - `documentation` to get information about functionality and data formats
  641. - `metrics` to get the list of available metrics
  642. - `metric_statistics` to get the information about metrics usage
  643. - `series` to get the time series for debugging
  644. - `metric_relabel_debug` to debug relabeling rules
  645. - `flags` to get the information about instance parameters
  646. - `downsampling_filters_debug` to debug downsampling configuration
  647. But you can use any other tools and combine them in your own way.
  648. ## Monitoring
  649. In [SSE and HTTP modes](#modes) the MCP Server provides metrics in Prometheus format (see [endpoints](#endpoints)) and you can find [in repo simple grafana dashboard](https://github.com/VictoriaMetrics/mcp-victoriametrics/blob/main/dashboard/mcp-victoriametrics-grafana.json) for these metrics.
  650. ## FAQ
  651. ### Why is the MCP server using more resources than I would expect from a simple API proxy?
  652. The server contains an embedded vector database with VictoriaMetrics documentation and blog posts for the `documentation` tool.
  653. It helps to answer complex questions about VictoriaMetrics without providing all data to LLM.
  654. This is the main source of resource usage. To reduce it, add `documentation` to `MCP_DISABLED_TOOLS` environment variable to completely disable the vector database loading.
  655. ### How to use one MCP server instance for several VictoriaMetrics instances?
  656. You can use `MCP_PASSTHROUGH_HEADERS` parameter in the MCP Server together with [Header-based routing in vmauth](https://docs.victoriametrics.com/victoriametrics/vmauth/#routing-by-header) to route MCP calls between instances based on HTTP header values from your MCP client config.
  657. ## Roadmap
  658. - [x] Support "Prettify query" tool (done in [`v0.0.5`](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/tag/v0.0.5))
  659. - [x] Support "Explain query" tool (done in [`v0.0.6`](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/tag/v0.0.6))
  660. - [x] Support CI pipeline for building and pushing multiarch docker images (done in [`v1.0.0`](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/tag/v1.0.0))
  661. - [x] Support tool for [unit-testing of alerting and recording rules](https://docs.victoriametrics.com/victoriametrics/vmalert-tool/) (done in [`v0.0.7`](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/tag/v0.0.7))
  662. - [x] Support optional integration with [VictoriaMetrics Cloud](https://victoriametrics.com/products/cloud/) (via [API keys](https://docs.victoriametrics.com/victoriametrics-cloud/api/)) (done in [`v0.0.9`](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/tag/v0.0.9))
  663. - [ ] Add some extra knowledge to server in addition to current documentation tool:
  664. - [x] [VictoriaMetrics blog](https://victoriametrics.com/blog/) posts (done in [`v1.1.0`](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/tag/v1.1.0))
  665. - [x] CRD schemas
  666. - [ ] Implement multitenant version of MCP (that will support several deployments)
  667. - [ ] Add flags/configs validation tool
  668. - [ ] Support tools for vmagent API
  669. - [ ] Support [new vmalert API](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/9046/files)
  670. - [x] Enabling/disabling tools via configuration (done in [`v0.0.8`](https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/tag/v0.0.8))
  671. - [ ] Tools for Alertmanager APIs [#6](https://github.com/VictoriaMetrics/mcp-victoriametrics/issues/6)
  672. - [x] Support for [metrics metadata](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/2974) in case of implementation in VictoriaMetrics
  673. - [x] Support authentication
  674. - [x] Add static index page with description and links to documentation
  675. ## Mentions
  676. [<img src="https://github.com/user-attachments/assets/76355b76-8a54-487d-a7d9-0b64886938fb" alt="How to Use an AI Assistant with Your Monitoring System – VictoriaMetrics MCP Server" width="520px" />](https://www.youtube.com/watch?v=1k7xgbRi1k0)
  677. [<img src="https://github.com/user-attachments/assets/2b93a545-7834-4020-aa2c-369ddcc90a29" alt="MCP Server Integration & Much More: What's New in VictoriaMetrics Cloud Q2 2025" width="520px" />](https://victoriametrics.com/blog/q2-2025-whats-new-victoriametrics-cloud/)
  678. ## Disclaimer
  679. AI services and agents along with MCP servers like this cannot guarantee the accuracy, completeness and reliability of results.
  680. You should double check the results obtained with AI.
  681. The quality of the MCP Server and its responses depends very much on the capabilities of your client and the quality of the model you are using.
  682. ## Contributing
  683. Contributions to the MCP VictoriaMetrics project are welcome!
  684. Please feel free to submit issues, feature requests, or pull requests.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.