Skip to content
Back to search

mcp-victorialogs

The implementation of Model Context Protocol (MCP) server for VictoriaLogs.

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-victorialogs 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-victorialogs'

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-victorialogs/badge.svg)](/listings/victoriametrics--mcp-victorialogs)

HTML

<a href="/listings/victoriametrics--mcp-victorialogs"><img src="/api/listings/victoriametrics--mcp-victorialogs/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.

Go

go install github.com/VictoriaMetrics/mcp-victorialogs/cmd/mcp-victorialogs@latest

Binaries

Just download the latest release from [Releases](https://github.com/VictoriaMetrics/mcp-victorialogs/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-victorialogs/releases/latest | grep 'tag_name' | cut -d\" -f4)
wget https://github.com/VictoriaMetrics/mcp-victorialogs/releases/download/$latest/mcp-victorialogs_Linux_x86_64.tar.gz
tar axvf mcp-victorialogs_Linux_x86_64.tar.gz

Docker

You can run VictoriaLogs 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-victorialogs \
  -e VL_INSTANCE_ENTRYPOINT=https://play-vmlogs.victoriametrics.com \
  -e MCP_SERVER_MODE=http \
  -e MCP_LISTEN_ADDR=:8081 \
  -p 8081:8081 \
  ghcr.io/victoriametrics/mcp-victorialogs

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-victorialogs).

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-victorialogs.git
  cd mcp-victorialogs

- Build binary from cloned source code:

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

- Build image from cloned source code:

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

Helm

Check out [VictoriaLogs MCP Server Helm chart](https://docs.victoriametrics.com/helm/victoria-logs-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 · 481 lines

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

  1. # VictoriaLogs MCP Server
  2. [![Latest Release](https://img.shields.io/github/v/release/VictoriaMetrics/mcp-victorialogs?sort=semver&label=&filter=!*-victorialogs&logo=github&labelColor=gray&color=gray&link=https%3A%2F%2Fgithub.com%2FVictoriaMetrics%2Fmcp-victorialogs%2Freleases%2Flatest)](https://github.com/VictoriaMetrics/mcp-victorialogs/releases)
  3. ![License](https://img.shields.io/github/license/VictoriaMetrics/mcp-victorialogs?labelColor=green&label=&link=https%3A%2F%2Fgithub.com%2FVictoriaMetrics%2Fmcp-victorialogs%2Fblob%2Fmain%2FLICENSE)
  4. ![Slack](https://img.shields.io/badge/Join-4A154B?logo=slack&link=https%3A%2F%2Fslack.victoriametrics.com)
  5. ![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)
  6. ![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)
  7. The implementation of [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server for [VictoriaLogs](https://docs.victoriametrics.com/victorialogs/).
  8. This provides access to your VictoriaLogs instance and seamless integration with [VictoriaLogs APIs](https://docs.victoriametrics.com/victorialogs/querying/#http-api) and [documentation](https://docs.victoriametrics.com/victorialogs/).
  9. It can give you a comprehensive interface for logs, observability, and debugging tasks related to your VictoriaLogs instances, enable advanced automation and interaction capabilities for engineers and tools.
  10. ## Features
  11. This MCP server allows you to use almost all read-only APIs of VictoriaLogs, i.e. all functions available in [Web UI](https://docs.victoriametrics.com/victorialogs/querying/#web-ui):
  12. - Querying logs and exploring logs data
  13. - Showing parameters of your VictoriaLogs instance
  14. - Listing available streams, fields, field values
  15. - Query statistics for the logs as metrics
  16. - UI with setup instructions and tools inspection on the root endpoint (only in Streamable HTTP mode)
  17. In addition, the MCP server contains embedded up-to-date documentation and is able to search it without online access.
  18. ![image](./ui.png)
  19. More details about the exact available tools and prompts can be found in the [Usage](#usage) section.
  20. You can combine functionality of tools, docs search in your prompts and invent great usage scenarios for your VictoriaLogs instance.
  21. 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.
  22. You can also combine the MCP server with other observability or doc search related MCP Servers and get even more powerful results.
  23. ## Try without installation
  24. There is a publicly available instance of the VictoriaMetrics MCP Server that you can use to test the features without installing it:
  25. ```
  26. https://play-vmlogs-mcp.victoriametrics.com/mcp
  27. ```
  28. **Attention!** This URL is not supposed to be opened in a browser, it is intended to be used in MCP clients.
  29. It's available in [Streamable HTTP Mode](#modes) mode and configured to work with [Public VictoriaLogs Playground](https://play-vmlogs.victoriametrics.com).
  30. Here is example of configuration for [Claude Desktop](https://claude.ai/download):
  31. ![image](https://github.com/user-attachments/assets/938d9eb9-f188-42f1-8377-a283be454ac7)
  32. ## Requirements
  33. - [VictoriaLogs](https://docs.victoriametrics.com/victorialogs/) instance: ([single-node](https://docs.victoriametrics.com/victorialogs/) or [cluster](https://docs.victoriametrics.com/victorialogs/cluster/))
  34. - Go 1.26 or higher (if you want to build from source)
  35. ## Installation
  36. ### Go
  37. ```bash
  38. go install github.com/VictoriaMetrics/mcp-victorialogs/cmd/mcp-victorialogs@latest
  39. ```
  40. ### Binaries
  41. Just download the latest release from [Releases](https://github.com/VictoriaMetrics/mcp-victorialogs/releases) page and put it to your PATH.
  42. Example for Linux x86_64 (note that other architectures and platforms are also available):
  43. ```bash
  44. latest=$(curl -s https://api.github.com/repos/VictoriaMetrics/mcp-victorialogs/releases/latest | grep 'tag_name' | cut -d\" -f4)
  45. wget https://github.com/VictoriaMetrics/mcp-victorialogs/releases/download/$latest/mcp-victorialogs_Linux_x86_64.tar.gz
  46. tar axvf mcp-victorialogs_Linux_x86_64.tar.gz
  47. ```
  48. ### Docker
  49. You can run VictoriaLogs MCP Server using Docker.
  50. This is the easiest way to get started without needing to install Go or build from source.
  51. ```bash
  52. docker run -d --name mcp-victorialogs \
  53. -e VL_INSTANCE_ENTRYPOINT=https://play-vmlogs.victoriametrics.com \
  54. -e MCP_SERVER_MODE=http \
  55. -e MCP_LISTEN_ADDR=:8081 \
  56. -p 8081:8081 \
  57. ghcr.io/victoriametrics/mcp-victorialogs
  58. ```
  59. You should replace environment variables with your own parameters.
  60. Note that the `MCP_SERVER_MODE=http` flag is used to enable Streamable HTTP mode.
  61. More details about server modes can be found in the [Configuration](#configuration) section.
  62. See available docker images in [github registry](https://github.com/orgs/VictoriaMetrics/packages/container/package/mcp-victorialogs).
  63. 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.
  64. ### Source Code
  65. For building binary from source code you can use the following approach:
  66. - Clone repo:
  67. ```bash
  68. git clone https://github.com/VictoriaMetrics/mcp-victorialogs.git
  69. cd mcp-victorialogs
  70. ```
  71. - Build binary from cloned source code:
  72. ```bash
  73. make build
  74. # after that you can find binary mcp-victorialogs and copy this file to your PATH or run inplace
  75. ```
  76. - Build image from cloned source code:
  77. ```bash
  78. docker build -t mcp-victorialogs .
  79. # after that you can use docker image mcp-victorialogs for running or pushing
  80. ```
  81. ### Helm
  82. Check out [VictoriaLogs MCP Server Helm chart](https://docs.victoriametrics.com/helm/victoria-logs-mcp/) documentation for more details about installation using Helm.
  83. ## Configuration
  84. MCP Server for VictoriaLogs is configured via environment variables:
  85. | Variable | Description | Required | Default | Allowed values |
  86. |----------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------|------------------|----------------------------------|
  87. | `VL_INSTANCE_ENTRYPOINT` | URL to VictoriaLogs instance | Yes | - | - |
  88. | `VL_INSTANCE_BEARER_TOKEN` | Authentication token for VictoriaLogs API | No | - | - |
  89. | `VL_INSTANCE_HEADERS` | Custom HTTP headers to send with requests (comma-separated key=value pairs) | No | - | - |
  90. | `MCP_PASSTHROUGH_HEADERS` | HTTP header names to forward from incoming MCP requests to VictoriaLogs (comma-separated list). Overrides `VL_INSTANCE_HEADERS` on collision. Only applies in `sse`/`http` modes. | No | - | - |
  91. | `VL_DEFAULT_TENANT_ID` | Default tenant ID used when tenant is not specified in requests (format: `AccountID:ProjectID` or `AccountID`) | No | `0:0` | - |
  92. | `MCP_SERVER_MODE` | Server operation mode. See [Modes](#modes) for details. | No | `stdio` | `stdio`, `sse`, `http` |
  93. | `MCP_LISTEN_ADDR` | Address for SSE or HTTP server to listen on | No | `localhost:8081` | - |
  94. | `MCP_DISABLED_TOOLS` | Comma-separated list of tools to disable | No | - | - |
  95. | `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` | - |
  96. | `MCP_LOG_FORMAT` | Log output format | No | `text` | `text`, `json` |
  97. | `MCP_LOG_LEVEL` | Minimum log level | No | `info` | `debug`, `info`, `warn`, `error` |
  98. ### Modes
  99. MCP Server supports the following modes of operation (transports):
  100. - `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.
  101. - `sse` - Server-Sent Events. Server will expose the `/sse` and `/message` endpoints for SSE connections.
  102. - `http` - Streamable HTTP. Server will expose the `/mcp` endpoint for HTTP connections.
  103. More info about transports you can find in MCP docs:
  104. - [Core concepts -> Transports](https://modelcontextprotocol.io/docs/concepts/transports)
  105. - [Specifications -> Transports](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports)
  106. ### Сonfiguration examples
  107. ```bash
  108. # For a public playground
  109. export VL_INSTANCE_ENTRYPOINT="https://play-vmlogs.victoriametrics.com"
  110. # Custom headers for authentication (e.g., behind a reverse proxy)
  111. # Expected syntax is key=value separated by commas
  112. export VL_INSTANCE_HEADERS="<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  113. # Forward specific headers from incoming MCP requests to VictoriaLogs
  114. export MCP_PASSTHROUGH_HEADERS="X-Token,X-Access-Key"
  115. # Server mode
  116. export MCP_SERVER_MODE="sse"
  117. export MCP_SSE_ADDR="0.0.0.0:8081"
  118. export MCP_DISABLED_TOOLS="hits,facets"
  119. ```
  120. ## Endpoints
  121. In SSE and HTTP modes the MCP server provides the following endpoints:
  122. | Endpoint | Description |
  123. |---------------------|--------------------------------------------------------------------------------------------------|
  124. | `/` | Landing page with setup help and tool inspection (HTTP mode only) |
  125. | `/sse` + `/message` | Endpoints for messages in SSE mode (for MCP clients that support SSE) |
  126. | `/mcp` | HTTP endpoint for streaming messages in HTTP mode (for MCP clients that support Streamable HTTP) |
  127. | `/metrics` | Metrics in Prometheus format for monitoring the MCP server |
  128. | `/health/liveness` | Liveness check endpoint to ensure the server is running |
  129. | `/health/readiness` | Readiness check endpoint to ensure the server is ready to accept requests |
  130. ## Setup in clients
  131. ### Cursor
  132. Go to: `Settings` -> `Cursor Settings` -> `MCP` -> `Add new global MCP server` and paste the following configuration into your Cursor `~/.cursor/mcp.json` file:
  133. ```json
  134. {
  135. "mcpServers": {
  136. "victorialogs": {
  137. "command": "/path/to/mcp-victorialogs",
  138. "env": {
  139. "VL_INSTANCE_ENTRYPOINT": "<YOUR_VL_INSTANCE>",
  140. "VL_INSTANCE_BEARER_TOKEN": "<YOUR_VL_BEARER_TOKEN>",
  141. "VL_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  142. }
  143. }
  144. }
  145. }
  146. ```
  147. See [Cursor MCP docs](https://docs.cursor.com/context/model-context-protocol) for more info.
  148. ### Claude Desktop
  149. Add this to your Claude Desktop `claude_desktop_config.json` file (you can find it if open `Settings` -> `Developer` -> `Edit config`):
  150. ```json
  151. {
  152. "mcpServers": {
  153. "victorialogs": {
  154. "command": "/path/to/mcp-victorialogs",
  155. "env": {
  156. "VL_INSTANCE_ENTRYPOINT": "<YOUR_VL_INSTANCE>",
  157. "VL_INSTANCE_BEARER_TOKEN": "<YOUR_VL_BEARER_TOKEN>",
  158. "VL_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  159. }
  160. }
  161. }
  162. }
  163. ```
  164. See [Claude Desktop MCP docs](https://modelcontextprotocol.io/quickstart/user) for more info.
  165. ### Claude Code
  166. Run the command:
  167. ```sh
  168. claude mcp add victorialogs -- /path/to/mcp-victorialogs \
  169. -e VL_INSTANCE_ENTRYPOINT=<YOUR_VL_INSTANCE> \
  170. -e VL_INSTANCE_BEARER_TOKEN=<YOUR_VL_BEARER_TOKEN> \
  171. -e VL_INSTANCE_HEADERS="<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  172. ```
  173. 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.
  174. ### Codex
  175. Codex CLI and the IDE extension use the same MCP configuration file: `~/.codex/config.toml`
  176. (or `.codex/config.toml` in a trusted project).
  177. Run the command:
  178. ```sh
  179. codex mcp add victorialogs \
  180. --env VL_INSTANCE_ENTRYPOINT=<YOUR_VL_INSTANCE> \
  181. --env VL_INSTANCE_BEARER_TOKEN=<YOUR_VL_BEARER_TOKEN> \
  182. --env VL_INSTANCE_HEADERS="<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>" \
  183. -- /path/to/mcp-victorialogs
  184. ```
  185. Or add the following to your Codex `~/.codex/config.toml` file:
  186. ```toml
  187. [mcp_servers.victorialogs]
  188. command = "/path/to/mcp-victorialogs"
  189. [mcp_servers.victorialogs.env]
  190. VL_INSTANCE_ENTRYPOINT = "<YOUR_VL_INSTANCE>"
  191. VL_INSTANCE_BEARER_TOKEN = "<YOUR_VL_BEARER_TOKEN>"
  192. VL_INSTANCE_HEADERS = "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  193. ```
  194. If you run the server in Streamable HTTP mode, you can register it with:
  195. ```sh
  196. codex mcp add victorialogs --url http://localhost:8081/mcp
  197. ```
  198. See [Codex MCP docs](https://developers.openai.com/codex/mcp) for more info.
  199. ### Visual Studio Code
  200. Add this to your VS Code MCP config file:
  201. ```json
  202. {
  203. "servers": {
  204. "victorialogs": {
  205. "type": "stdio",
  206. "command": "/path/to/mcp-victorialogs",
  207. "env": {
  208. "VL_INSTANCE_ENTRYPOINT": "<YOUR_VL_INSTANCE>",
  209. "VL_INSTANCE_BEARER_TOKEN": "<YOUR_VL_BEARER_TOKEN>",
  210. "VL_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  211. }
  212. }
  213. }
  214. }
  215. ```
  216. See [VS Code MCP docs](https://code.visualstudio.com/docs/copilot/chat/mcp-servers) for more info.
  217. ### Zed
  218. Add the following to your Zed config file:
  219. ```json
  220. "context_servers": {
  221. "victorialogs": {
  222. "command": {
  223. "path": "/path/to/mcp-victorialogs",
  224. "args": [],
  225. "env": {
  226. "VL_INSTANCE_ENTRYPOINT": "<YOUR_VL_INSTANCE>",
  227. "VL_INSTANCE_BEARER_TOKEN": "<YOUR_VL_BEARER_TOKEN>",
  228. "VL_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  229. }
  230. },
  231. "settings": {}
  232. }
  233. }
  234. }
  235. ```
  236. See [Zed MCP docs](https://zed.dev/docs/ai/mcp) for more info.
  237. ### JetBrains IDEs
  238. - Open `Settings` -> `Tools` -> `AI Assistant` -> `Model Context Protocol (MCP)`.
  239. - Click `Add (+)`
  240. - Select `As JSON`
  241. - Put the following to the input field:
  242. ```json
  243. {
  244. "mcpServers": {
  245. "victorialogs": {
  246. "command": "/path/to/mcp-victorialogs",
  247. "env": {
  248. "VL_INSTANCE_ENTRYPOINT": "<YOUR_VL_INSTANCE>",
  249. "VL_INSTANCE_BEARER_TOKEN": "<YOUR_VL_BEARER_TOKEN>",
  250. "VL_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  251. }
  252. }
  253. }
  254. }
  255. ```
  256. ### Windsurf
  257. Add the following to your Windsurf MCP config file.
  258. ```json
  259. {
  260. "mcpServers": {
  261. "victorialogs": {
  262. "command": "/path/to/mcp-victorialogs",
  263. "env": {
  264. "VL_INSTANCE_ENTRYPOINT": "<YOUR_VL_INSTANCE>",
  265. "VL_INSTANCE_BEARER_TOKEN": "<YOUR_VL_BEARER_TOKEN>",
  266. "VL_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  267. }
  268. }
  269. }
  270. }
  271. ```
  272. See [Windsurf MCP docs](https://docs.windsurf.com/windsurf/mcp) for more info.
  273. ### Using Docker instead of binary
  274. You can run VictoriaLogs MCP Server using Docker instead of local binary.
  275. You should replace run command in configuration examples above in the following way:
  276. ```
  277. {
  278. "mcpServers": {
  279. "victorialogs": {
  280. "command": "docker",
  281. "args": [
  282. "run",
  283. "-i", "--rm",
  284. "-e", "VL_INSTANCE_ENTRYPOINT",
  285. "-e", "VL_INSTANCE_BEARER_TOKEN",
  286. "-e", "VL_INSTANCE_HEADERS",
  287. "ghcr.io/victoriametrics/mcp-victorialogs",
  288. ],
  289. "env": {
  290. "VL_INSTANCE_ENTRYPOINT": "<YOUR_VL_INSTANCE>",
  291. "VL_INSTANCE_BEARER_TOKEN": "<YOUR_VL_BEARER_TOKEN>",
  292. "VL_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
  293. }
  294. }
  295. }
  296. }
  297. ```
  298. ## Usage
  299. After [installing](#installation) and [configuring](#setup-in-clients) the MCP server, you can start using it with your favorite MCP client.
  300. You can start dialog with AI assistant from the phrase:
  301. ```
  302. Use MCP VictoriaLogs in the following answers
  303. ```
  304. 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.
  305. ### Toolset
  306. MCP VictoriaLogs provides numerous tools for interacting with your VictoriaLogs instance.
  307. Here's a list of available tools:
  308. | Tool | Description |
  309. |----------------------|-------------------------------------------------------|
  310. | `documentation` | Search in embedded VictoriaLogs documentation |
  311. | `facets` | Most frequent values per each log field |
  312. | `field_names` | List of field names for the query |
  313. | `field_values` | List of field values for the query |
  314. | `flags` | View non-default flags of the VictoriaLogs instance |
  315. | `hits` | The number of matching log entries grouped by buckets |
  316. | `query` | Execute LogsQL queries |
  317. | `stats_query` | Querying log stats for the given time |
  318. | `stats_query_range` | Querying log stats on the given time range |
  319. | `stream_field_names` | List of stream fields for the query |
  320. | `stream_field_values` | List of stream field values for the query |
  321. | `stream_ids` | List of stream IDs for the query |
  322. | `streams` | List of streams for the query |
  323. ### Prompts
  324. The server includes pre-defined prompts for common tasks.
  325. These are just examples at the moment, the prompt library will be added to in the future:
  326. | Prompt | Description |
  327. |--------|-------------------------------------------------------|
  328. | `documentation` | Search VictoriaLogs documentation for specific topics |
  329. ## FAQ
  330. ### Why is the MCP server using more resources than I would expect from a simple API proxy?
  331. The server contains an embedded vector database with VictoriaMetrics documentation and blog posts for the `documentation` tool.
  332. It helps to answer complex questions about VictoriaLogs without providing all data to LLM.
  333. 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.
  334. ### How to use one MCP server instance for several VictoriaMetrics instances?
  335. 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.
  336. ## Roadmap
  337. - [ ] Support "Explain query" tool
  338. - [ ] Support optional integration with [VictoriaMetrics Cloud](https://victoriametrics.com/products/cloud/)
  339. - [ ] Add some extra knowledge to server in addition to current documentation tool:
  340. - [x] [VictoriaMetrics blog](https://victoriametrics.com/blog/) posts
  341. - [ ] Github issues
  342. - [ ] Public slack chat history
  343. - [ ] CRD schemas
  344. - [ ] Implement multitenant version of MCP (that will support several deployments)
  345. - [ ] Add flags/configs validation tool
  346. - [x] Enabling/disabling tools via configuration
  347. ## Disclaimer
  348. AI services and agents along with MCP servers like this cannot guarantee the accuracy, completeness and reliability of results.
  349. You should double check the results obtained with AI.
  350. 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.
  351. ## Contributing
  352. Contributions to the MCP VictoriaLogs project are welcome!
  353. 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.