Zabbix MCP Server A765fbbc

MCP开发工具

提供方 initMAX

开发工具 stdio · 本地进程 OAuth 授权 社区 / 第三方 Claude DesktopClaudeCursorCline
查看接入方式

提供完整的Zabbix API访问,支持通过Claude、Codex、VS Code、JetBrains等MCP客户端进行远程监控和管理。

一句话选型结论

按资料字段整理

Zabbix MCP Server A765fbbc 属于开发工具类 MCP 服务器,stdio · 本地进程,OAuth 授权,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接复制的远程端点配置。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式stdio · 本地进程 鉴权OAuth 授权 部署方式支持远程部署
GitHub 星标 98 仓库热度,无公开仓库时显示未标注
工具数 36 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量36暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

ZabbixAPIPython本地部署监控工具AI集成自动化管理开发效率

安装与配置

stdio · 本地进程 OAuth 授权
客户端在本机拉起子进程,数据不出本机
python3 -c "import secrets,hashlib; t='zmcp_'+secrets.token_hex(32); print(f'Token: {t}\nHash: sha256:{hashlib.sha256(t.encode()).hexdigest()}')"

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    确认你的客户端支持远程端点,并拿到服务地址。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后客户端会列出约 36 个工具,随便调一个只读工具确认能返回结果。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 资料标注 36 个工具,覆盖面较广,能满足多种调用。
  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好OAuth 授权对应的凭据,并按最小权限配置。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Zabbix MCP Server A765fbbc当前 36 stdio · 本地进程 支持远程部署 有 2026-05-17
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方initMAX上游标注的维护方 initMAX
分类开发工具本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式OAuth 授权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Python本地安装时用到的包标识与运行时
部署类型支持远程部署上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

82.3 KB
来自项目仓库与上游目录的原文,未做删改

Zabbix MCP Server

    developed and maintained by

    and community

    Full Zabbix API access from Claude, Codex, VS Code, JetBrains, and other MCP clients.

Table of Contents

Overview: What is this? · Features

Install: Quick Start · Installation · Upgrade · First-time admin access

Configure: Reference · OAuth 2.1 · Public URL · TLS / HTTPS · Token Budget

Use: Client Wizard · AI Clients · Prompts · Tools · Parameters · Round trip · Time zones · PDF Reports

Operate: Installer CLI · Update notifications · Compatibility · Development · Related Projects · License

What is this?

MCP (Model Context Protocol) is an open standard that lets AI assistants (ChatGPT, Claude, VS Code Copilot, JetBrains AI, Codex, and others) use external tools. This server exposes the entire Zabbix API as MCP tools — allowing any compatible AI assistant to query hosts, check problems, manage templates, acknowledge events, and perform any other Zabbix operation.

The server runs as a standalone HTTP service. AI clients connect to it over the network.

Features

  • Complete API coverage - All 68 Zabbix API groups (241 tools): hosts, problems, triggers, templates, users, dashboards, and more
  • Extension tools (14) - Pre-correlated views: host_status_get, hostgroup_overview_get, infrastructure_summary_get, item_history_summary_get, problem_active_get (fold 3-5 raw API calls into one round-trip). Plus graph_render (PNG export), anomaly_detect (z-score analysis), capacity_forecast (linear regression), item_threshold_search (filter items by lastvalue thresholds), report_generate (PDF reports), action_prepare/action_confirm (two-step write approval), health_check (server diagnostics) and zabbix_raw_api_call (admin escape hatch for un-wrapped methods).
  • Admin web portal - Full web UI on port 9090 for managing tokens, users, servers, templates, settings, and audit log; dark/light mode; point-and-click Client MCP Wizard (beta) that generates copy-paste-ready config snippets for 14 AI clients (Claude, Codex, Cursor, Cline, VS Code, JetBrains, Goose, Open WebUI, 5ire, Gemini CLI, n8n, ...)
  • Multi-token authentication - Named tokens with scopes, IP restrictions, server binding, expiry; managed via admin portal, CLI (generate-token), or config.toml
  • Multi-server support - Connect to multiple Zabbix instances (production, staging, ...) with separate tokens
  • HTTP + SSE transports - Streamable HTTP (recommended) and SSE for clients like n8n that lack session management
  • Tool filtering - Limit exposed tools by category (monitoring, alerts, users, extensions, etc.) or individual API prefix to reduce the tool catalog size and stay under LLM context limits (see Token Budget below)
  • Compact output mode - Get methods return only key fields by default, reducing response token usage; LLM can request extend for full details
  • LLM-friendly normalizations - Symbolic enum names, auto-fill defaults, preprocessing cleanup, timestamp conversion with local-time rendering (_local siblings and a per-call zone note, see Time zones)
  • Single config file - One TOML file, no scattered environment variables
  • Read-only mode - Per-server and per-token write protection to prevent accidental changes
  • Rate limiting - Per-client call budget (300/min default) to protect Zabbix from flooding
  • Auto-reconnect - Transparent re-authentication on session expiry
  • Production-ready - systemd service, logrotate, Docker support, security hardening
  • Generic fallback - zabbix_raw_api_call tool for any API method not explicitly defined

Quick Start```bash

git clone https://github.com/initMAX/zabbix-mcp-server.git
cd zabbix-mcp-server
sudo ./deploy/install.sh
sudo nano /etc/zabbix-mcp/config.toml # fill in your Zabbix URL + API token
sudo systemctl start zabbix-mcp-server
sudo systemctl enable zabbix-mcp-server


Done. The server is running on `http://127.0.0.1:8080/mcp`.

## Installation

> **Detailed guide:** See `INSTALL.md` for step-by-step instructions for both on-prem (systemd) and Docker deployments, including uninstall, security checklist, and TLS setup.

### Requirements

- Linux server with Python 3.10+
- Network access to your Zabbix server(s)
- A Zabbix **API token** (User settings > API tokens). Zabbix 5.0 and 5.2 have no API tokens; for those two releases only, an explicit legacy password login exists - see Legacy auth and read the warning there first

### Install```bash
git clone https://github.com/initMAX/zabbix-mcp-server.git
cd zabbix-mcp-server
sudo ./deploy/install.sh

The install script will:
1. Create a dedicated system user zabbix-mcp (no login shell)
2. Create a Python virtual environment in /opt/zabbix-mcp/venv
3. Install the server and all dependencies
4. Copy the example config to /etc/zabbix-mcp/config.toml
5. Install a systemd service unit (zabbix-mcp-server)
6. Set up logrotate for /var/log/zabbix-mcp/*.log (daily, 30 days retention)
7. Verify file permissions and offer to fix any issues

User-mode install (no root, dev / laptop use)

For developers running the server locally on their own machine, an alternative installer is shipped that does not require sudo:```bash
./deploy/install-user.sh # install
./deploy/install-user.sh update # git pull + pip + restart
./deploy/install-user.sh uninstall


It detects Python 3.10+, creates a virtualenv inside the repo, copies `config.example.toml` to `config.toml` (with `log_file` rewritten to a user-writable path), and registers a background service:

- **macOS** - LaunchAgent at `~/Library/LaunchAgents/com.initmax.zabbix-mcp-server.plist` (auto-restart via `KeepAlive`)
- **Linux** - systemd `--user` unit at `~/.config/systemd/user/zabbix-mcp-server.service` with `loginctl enable-linger` so the service survives logout

This is intended for local development. For production servers use the regular `sudo ./deploy/install.sh` above.

### Upgrade```bash
cd zabbix-mcp-server
sudo ./deploy/install.sh update

That's the whole procedure — no manual steps afterwards. From v1.15+ the update command handles git sync, package reinstall, systemd reload, validation, and service restart in one shot.

What update does:

  1. Pulls latest code from the current branch (fast-forward; falls back to fetch + reset --hard origin/ if history diverged), then re-executes itself from the updated script.
  2. Reinstalls the Python package into /opt/zabbix-mcp/venv.
  3. Refreshes the systemd unit and logrotate config (in case they changed between releases).
  4. Checks file permissions and offers to fix any ownership issues.
  5. Runs small migrations (legacy token, report templates) and validates config.toml — aborts if the config is invalid.
  6. Restarts the service via systemctl restart zabbix-mcp-server and performs an HTTP health check on the configured port.

What is preserved (never overwritten):

  • /etc/zabbix-mcp/config.toml — your Zabbix URL, API token, MCP tokens, scopes, TLS settings, etc.
  • Admin portal users (stored in [admin.users.*] inside config.toml).
  • Audit log, report templates, and any custom data.

You'll see ✓ Config preserved at /etc/zabbix-mcp/config.toml (not overwritten) during the update. Check config.example.toml afterwards for any new options added in the release.

PDF reporting during update:

By default update keeps your current reporting state — if PDF reporting was installed, it stays; if it wasn't, it is not added. To change that:```bash

Enable PDF reporting on an existing install that didn't have it

sudo ./deploy/install.sh update --with-reporting

Update without PDF reporting dependencies (smaller install)

sudo ./deploy/install.sh update --without-reporting


The `--with-reporting` flag pulls in `weasyprint`, `jinja2`, and system libs (`cairo`, `pango`, `gdk-pixbuf`). See PDF Reports for what you get.

> **Upgrading from very old versions (pre-v1.15)?** If `update` fails, do a one-time manual sync first:
>```bash
> git fetch origin && git reset --hard origin/main
> sudo ./deploy/install.sh update
> ```
>
> **Troubleshooting:** if something goes wrong, inspect:
>```bash
> sudo ./deploy/install.sh test-config       # validate config.toml
> sudo journalctl -u zabbix-mcp-server -n 50 --no-pager
> ```

### Configure

Edit the config file with your Zabbix server details:```bash
sudo nano /etc/zabbix-mcp/config.toml

Minimal configuration - just fill in your Zabbix URL and API token:```toml
[server]
transport = "http"
host = "127.0.0.1"
port = 8080

[zabbix.production]
url = "https://zabbix.example.com"
api_token = "your-api-token"
read_only = true
verify_ssl = true


All available options with detailed descriptions are documented in `config.example.toml`.

#### Authentication — two tokens explained

The config file contains **two different types of tokens** that serve different purposes:```
┌────────────┐  MCP token (Bearer)  ┌──────────────────┐   api_token     ┌───────────────┐
│ MCP Client ├──────────────────────► MCP Server       ├─────────────────► Zabbix Server │
│ (AI / IDE) │    (optional)        │ (zabbix-mcp)     │   (required)    │               │
└────────────┘                      │                  │                 └───────────────┘
                                    │ Admin Portal     │
                                    │ :9090 (optional) │
                                    └──────────────────┘

api_token (in [zabbix.*]) — authenticates the MCP server to your Zabbix instance. This is a Zabbix API token that you create in the Zabbix frontend. It is required. The only exception is the explicit legacy password login for Zabbix 5.0 and 5.2 - see Legacy auth.

How to create one:

  1. In Zabbix frontend: Users → API tokens → Create API token
  2. Select the user the token will belong to
  3. Optionally set an expiration date
  4. Copy the generated token — it is shown only once

The token inherits the permissions of the Zabbix user it belongs to:

Use case Recommended Zabbix role read_only config
Read-only monitoring (problems, hosts, dashboards) User role with read access to needed host groups true
Full management (create hosts, templates, triggers) Admin role with read-write access to target host groups false
Complete API access (users, settings, global scripts) Super admin role false

Use the principle of least privilege — create a dedicated Zabbix user for the MCP server with only the permissions it needs.

Legacy auth (Zabbix 5.0 and 5.2 only)

> Read this before enabling it. Zabbix 5.0 and 5.2 are out of upstream support and have no API tokens - they were introduced in 5.4. The only way in is a username and password, which means this server holds a user password in its configuration instead of a revocable, scoped token. That is a security risk you are choosing to carry, and this project treats the whole path as best effort: it is not in our test matrix and we cannot verify it against a live 5.x. The right fix is upgrading Zabbix. If you cannot yet, this exists so you are not locked out in the meantime.

It has to be switched on explicitly. A username/password pair without the flag is a configuration error, not a fallback:```toml
[zabbix.old-prod]
url = "https://zabbix5.example.com"
legacy_auth = true # the switch - Zabbix 5.0 / 5.2 only
username = "zabbix-mcp" # dedicated low-privilege account
password = "${ZABBIX_OLD_PASSWORD}" # keep it in the environment, not the file
read_only = true


Rules the server enforces:

- `legacy_auth = true` and `api_token` on the same entry is refused - one credential per server, nothing inferred.
- `username`/`password` without `legacy_auth = true` is refused.
- **Version lock:** on connect the server reads `apiinfo.version` and refuses legacy login against anything **5.4 or newer**. On a current Zabbix the flag does nothing except fail loudly, so it cannot be used to avoid tokens where they exist.
- Every start logs a `WARNING` for each legacy entry naming the Zabbix version, so the choice stays visible in the operational log.
- The admin portal shows the same warning on the server card and in the Add / Edit form, and the password is never sent back to the browser.

The session from `user.login` expires; the server re-authenticates automatically when Zabbix answers that it has. Use a dedicated Zabbix user with only the permissions the tools need, and `read_only = true` unless writes are genuinely required.

**Keeping the password out of the config file:** `username` and `password` support `${ENV_VAR}` expansion. Under Docker, put the variable in `.env` (the compose file injects it via `env_file`):```bash
# .env
ZABBIX_OLD_PASSWORD=your-password-here

The zabbix-utils library this server uses refuses Zabbix below 6.0 by default; the version check is relaxed only for entries marked legacy_auth, never for token authentication.

MCP Authentication (optional)

Protects the MCP server from unauthorized access. When configured, MCP clients must include a bearer token in every request: Authorization: Bearer.

Recommended: Multi-token system (v1.16+) — generate tokens via installer, admin portal, or manually:```bash

Generate a token via installer

sudo ./deploy/install.sh generate-token claude

Or generate manually

python3 -c "import secrets,hashlib; t='zmcp_'+secrets.token_hex(32); print(f'Token: {t}\nHash: sha256:{hashlib.sha256(t.encode()).hexdigest()}')"


Then add to `config.toml`:```toml
[tokens.claude]
name = "Claude Code"
token_hash = "sha256:<paste hash>"
scopes = ["*"]           # or specific: ["monitoring", "alerts"]
read_only = true

Each token can have independent scopes, IP restrictions, server binding, expiry, and time zone (timezone = "Europe/London", see Time zones). See config.example.toml for all options.

Legacy: Single auth_token — still supported for backward compatibility:```toml
[server]
auth_token = "your-secret-token-here"


> Legacy `auth_token` is automatically migrated to `[tokens.legacy]` on first v1.16 start.

When no tokens are configured, the server accepts unauthenticated connections. This is safe when bound to `127.0.0.1` (default) but **must be configured** when exposed to the network (`0.0.0.0`).

**OAuth 2.1** (v1.28+) — for clients that auto-discover authentication (ChatGPT custom apps, Claude Desktop remote, MCP Inspector). Enable with:```toml
[server]
public_url = "https://mcp.example.com"  # required when OAuth is on

[oauth]
enabled = true

Login uses the existing admin-portal users. Dynamic client registration (RFC 7591) is on by default; ChatGPT's "Advanced OAuth settings" auto-detects everything from the .well-known/... discovery documents. The legacy [tokens.X] bearer mode keeps working alongside OAuth - existing CLI scripts and workflow tools need no change.

Full setup, security checklist, and troubleshooting in docs/OAUTH.md.

Multiple Zabbix servers

You can connect to multiple Zabbix instances. Each tool has a server parameter to select which one to use (defaults to the first defined):```toml
[zabbix.production]
url = "https://zabbix.example.com"
api_token = "prod-token"
read_only = true

[zabbix.staging]
url = "https://zabbix-staging.example.com"
api_token = "staging-token"
read_only = false


The first server (`production`) is used as the default. One exception: when the MCP token making the call is restricted through `allowed_servers`, the default for the call is one of its own servers (the global default if it is among them, else the first listed), so per-user or per-customer tokens, each pointing at its own `[zabbix.]` entry, work without naming the server every time. Such a token also sees only its own servers: the `server` parameter in `tools/list` and the "Unknown Zabbix server" message name nothing else (since v1.41, MSP setups where the instance name is the customer name). To target a specific instance, just mention it naturally in your prompt:

#### Prompt examples

| Prompt                                                           | Target server        | What happens                                                        |
|------------------------------------------------------------------|----------------------|---------------------------------------------------------------------|
| *"Show me hosts with high CPU usage"*                            | `production` (default) | Queries the first defined server automatically                    |
| *"Show me hosts in our staging Zabbix instance"*                 | `staging`            | AI recognizes "staging" and routes to the matching server            |
| *"What are the top triggers in the last hour on production?"*    | `production`         | Explicit mention of "production" confirms the default               |
| *"Compare trigger counts between production and staging"*        | both                 | AI queries both servers and combines the results                    |
| *"Create a maintenance window on staging for tonight"*           | `staging`            | Write operation routed to staging (requires `read_only = false`)    |
| *"Acknowledge all disaster problems on production"*              | `production`         | Write operation on production (blocked if `read_only = true`)       |
| *"Export the 'Linux by Zabbix agent' template from production"*  | `production`         | Read-only export, works even with `read_only = true`                |
| *"Import this template to staging"*                              | `staging`            | Write operation routed to staging                                   |
| *"Migrate host 'web-01' from production to staging"*             | both                 | AI reads from production, creates on staging                        |

The AI assistant maps your natural language to the correct `server` parameter automatically — no need to use technical syntax like `server = "staging"` in your prompts.

#### High Availability

The MCP server itself is **stateless** — there is no shared state between instances. You can run multiple MCP server instances behind a reverse proxy (nginx, HAProxy, Caddy) using round-robin load balancing. Each instance connects to Zabbix independently.

> **Note:** When your Zabbix runs in HA mode with multiple frontends, the API is available on each frontend. Currently the MCP server connects to a single `url` per `[zabbix.]` entry. Multi-frontend failover (connecting to multiple URLs for the same Zabbix instance) is a planned feature.

### Start```bash
sudo systemctl start zabbix-mcp-server
sudo systemctl enable zabbix-mcp-server

Verify the server is running:```bash
sudo systemctl status zabbix-mcp-server


### Health Check

The server exposes two health check mechanisms:

| Method | Endpoint | Auth required | Returns |
|--------|----------|---------------|---------|
| HTTP endpoint | `GET /health` | No | `{"status": "ok"}` — confirms the HTTP server is running |
| MCP tool | `health_check` | Yes (if auth_token set) | Full connectivity status of each configured Zabbix server |

**Quick check from the command line:**```bash
# Simple HTTP health check (no authentication needed)
curl http://localhost:8080/health
# → {"status":"ok"}

Use the HTTP /health endpoint for load balancer probes, uptime monitoring, and container orchestration readiness checks. Use the health_check MCP tool for deeper diagnostics including Zabbix server connectivity.

Logs

The application writes to the log file configured in config.toml (log_file). Startup errors before logging initialization go to the systemd journal.```bash

Live log stream (application log)

tail -f /var/log/zabbix-mcp/server.log

Via journalctl (startup errors + fallback)

sudo journalctl -u zabbix-mcp-server -f


### Admin Portal

Web-based administration portal for managing MCP tokens, users, report templates, and server settings. Runs on a **separate port** (default: 9090) — the MCP port (8080) serves only the MCP protocol, no admin UI.```toml
[admin]
enabled = true
port = 9090

The installer generates an admin password automatically. To reset: sudo ./deploy/install.sh set-admin-password

Features:

Feature Description
Dashboard System overview with MCP health status (green/red dot), Zabbix server connectivity with async token validation, uptime, recent audit activity
MCP Tokens Create, revoke, per-token scope control (group + individual tool level), per-token Zabbix server binding, IP restrictions, expiry, read-only flag; legacy token migration with tooltip
Tool Exposure Drag & drop bubble UI for enabling/disabling tools globally and per-token; groups + individual tool prefixes; globally disabled tools shown as locked in token scopes
Zabbix Servers Connection status with API + token validation (detects "API online but token invalid"), version display, test connection, add/edit/delete
Client MCP Wizard (beta) Point-and-click generator: pick a Zabbix server -> pick a token (or skip auth) -> pick one of 14 AI clients -> get a copy-paste-ready config snippet + per-client install instructions. Handles URL composition, 0.0.0.0 host override, transport picker, token substitution in the snippet and curl test. Feedback wanted - please report issues at https://github.com/initMAX/zabbix-mcp-server/issues.
Users Admin / operator / viewer roles; password complexity enforcement (10+ chars, uppercase, digit)
Report Templates Built-in + custom templates, GrapesJS visual editor with Zabbix blocks, HTML code editor, variable picker, server-side Jinja2 preview
Settings All config.toml sections editable — MCP Server, TLS & Security, Tool Exposure (allowlist + denylist), PDF Reports & Branding, Admin Portal
Audit Log All admin actions logged (JSON lines), filterable by date/action/user, CSV export
Restart Management Blikající "Restart needed" badge in header after config changes; click to restart with progress bar polling until MCP is back online
Design initMAX branded, dark/light/auto mode, Rubik font, instant CSS tooltips, responsive mobile layout

All changes are written back to config.toml (preserving comments and formatting via tomlkit). Every config change triggers a "Restart needed" indicator.

Client MCP Wizard (beta)

> Beta - introduced in v1.20 with 14 supported clients and wide test coverage, but we are still collecting real-world feedback on the per-client snippets, the OAuth-vs-Bearer handling (especially Claude Desktop + ChatGPT), and edge cases around Docker / NAT / reverse-proxy host overrides. Please report issues at https://github.com/initMAX/zabbix-mcp-server/issues so we can graduate it out of beta.

A standalone page at /wizard (sidebar entry Client MCP Wizard) that replaces hand-editing JSON / TOML config files for 14 AI clients. Single-page progressive disclosure in four steps:

  1. Pick a Zabbix server - cards list all [zabbix.*] entries from config.toml.
  2. Pick an MCP token - cards show every token whose allowed_servers includes the chosen server, plus per-token scope chips (groups + individual prefixes), IP restrictions, and expiry. When the MCP server is in no-auth mode, a Continue without token card generates a tokenless snippet; when auth is enabled, the + Create new token card chains into /tokens/create?return_to=/wizard and comes back with the new token pre-filled via a URL fragment (never sent to the server).
  3. Pick your AI client - grid of 14 cards: Claude Desktop, Claude Code (CLI), OpenAI Codex, ChatGPT, VS Code + GitHub Copilot, Cursor, Cline, JetBrains AI, Goose, Open WebUI, 5ire, Gemini CLI, n8n, Generic MCP Client.
  4. Copy the config - host override picker when [server].host = 0.0.0.0 (Docker container IPs are de-emphasized with a manual-entry input on top), transport picker with a "detected" badge on the running transport, per-client install instructions on the left, syntax-highlighted snippet on the right with a copy-on-hover overlay icon, download-as-file button, and a matching curl quick-test block. Both code blocks substitute a pasted Bearer token live so the operator can verify before copying.

Every snippet and instruction set comes from a single-source-of-truth catalog (src/zabbix_mcp/admin/wizard_clients.py) cross-checked against each client's current official documentation (Claude Desktop via mcp-remote wrapper for Bearer tokens, Claude Code with the --transport / --header flag rename from 2025, ChatGPT Developer-mode Apps & Connectors path, Gemini CLI httpUrl vs url key split, Goose Streamable HTTP YAML schema, Open WebUI native MCP since v0.6.31, etc.).

> Port separation: MCP endpoint (/mcp, /health) runs exclusively on the MCP port (default 8080). Admin portal runs exclusively on the admin port (default 9090). No admin API is exposed on the MCP port. Firewall both ports independently.

Docker```bash

git clone https://github.com/initMAX/zabbix-mcp-server.git
cd zabbix-mcp-server
cp config.example.toml config.toml
nano config.toml # fill in your Zabbix details
cp .env.example .env # optional: customize port, host, auth token
docker compose up -d


The config file is mounted read-write into the container (admin portal writes changes back). Logs are stored in a Docker volume.

**Customizing the port and host interface** — create a `.env` file (copy from `.env.example`) and set:```bash
MCP_HOST=127.0.0.1   # interface to bind on the Docker host (default: 127.0.0.1)
MCP_PORT=8080        # port used inside the container and exposed on the host (default: 8080)
MCP_AUTH_TOKEN=...   # bearer token for MCP server authentication (optional)

MCP_PORT controls both the container-internal port and the host-side binding — no need to edit docker-compose.yml. The port setting in config.toml is ignored when running via Docker (overridden by MCP_PORT).

> Security: Docker deployments are typically exposed to the network. Generate an MCP token (sudo ./deploy/install.sh generate-token) or add a [tokens.*] section in config.toml to require authentication. See MCP Authentication above.

Upgrade:```bash
git pull
docker compose up -d --build


**Logs:**```bash
docker compose logs -f

Manual Installation (pip)

If you prefer to install manually without the deploy script:```bash
python3 -m venv /opt/zabbix-mcp/venv
/opt/zabbix-mcp/venv/bin/pip install /path/to/zabbix-mcp-server
/opt/zabbix-mcp/venv/bin/zabbix-mcp-server --config /path/to/config.toml


## Connecting AI Clients

> **Recommended (beta):** use the **Client MCP Wizard** in the admin portal at `/wizard`. It generates copy-paste-ready config snippets for 14 AI clients (Claude Desktop, Codex, Cursor, Cline, VS Code Copilot, JetBrains AI, Goose, Open WebUI, 5ire, Gemini CLI, n8n, Claude Code, ChatGPT, Generic) with the correct URL, transport, and Bearer header substitution. Still beta - feedback welcome at https://github.com/initMAX/zabbix-mcp-server/issues. The manual instructions below stay for reference.

The server uses the **Streamable HTTP** transport by default and listens on `http://127.0.0.1:8080/mcp`. SSE transport is also available (`http://127.0.0.1:8080/sse`) for clients that do not support Streamable HTTP session management.

**MCP** (Model Context Protocol) is an open standard that lets AI assistants use external tools. Any MCP-compatible client can connect to this server - ChatGPT, VS Code, Claude, Codex, JetBrains, and others.

To connect an MCP client to the server, you need 3 things from your server configuration:

#### Step 1: Find your server settings

Check your **admin portal** (Settings → MCP Server) or **config.toml** for 3 values — transport, address, and token:```toml
[server]
transport = "http"
host = "0.0.0.0"
port = 8888
auth_token = "XXXXXXXXXXXXX"
  • Transport → determines the client URL path and the "type" field in client config:
Your transport Client "type" Client URL
HTTP (Streamable HTTP — recommended) "type": "http" http://your-server:port/mcp
SSE (Server-Sent Events) "type": "sse" http://your-server:port/sse
STDIO (subprocess mode) (not applicable) (no URL — client launches server locally)
  • Host + Port → your server's IP address and port (e.g. 10.0.0.5:8888). If host is 0.0.0.0, use your server's actual IP.

Step 2: Check if token authentication is required

If auth_token exists in your config.toml or you see tokens in the admin portal (MCP Tokens page), clients must include the token in the Authorization header. If no tokens are configured, skip this step — no header needed.```toml
[server]
transport = "http"
host = "0.0.0.0"
port = 8888
auth_token = "XXXXXXXXXXXXX"


> **Optional:** You can generate new tokens via `sudo ./deploy/install.sh generate-token ` or in admin portal → MCP Tokens → Create Token. The token value is shown only once at creation. The `auth_token` value from config.toml can also be used directly.

#### Step 3: Configure your AI client

##### Claude Code (CLI) — examples```bash
# HTTP transport, no token
claude mcp add --transport http zabbix http://your-server:8080/mcp

# HTTP transport, with token
claude mcp add --transport http zabbix http://your-server:8080/mcp \
    --header "Authorization: Bearer zmcp_your-token-here"

# SSE transport, with token
claude mcp add --transport sse zabbix http://your-server:8080/sse \
    --header "Authorization: Bearer zmcp_your-token-here"

# STDIO transport (local subprocess)

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Zabbix MCP Server A765fbbc 怎么安装?

在客户端按下面的安装命令接入:python3 -c "import secrets,hashlib; t='zmcp_'+secrets.token_hex(32); print(f'Token: {t}\nHash: sha256:{hashlib.sha256(t.encode()).hexdigest()}')"。装完在客户端配置里引用同一个包或端点。

Zabbix MCP Server A765fbbc 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Zabbix MCP Server A765fbbc 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Zabbix MCP Server A765fbbc 需要 API Key 吗?

资料标注需要OAuth 授权认证,使用前准备好对应凭据,并按最小权限配置。

Zabbix MCP Server A765fbbc 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、Cline、VS Code;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Zabbix MCP Server A765fbbc 能提供哪些能力?

资料显示约 36 个工具;能力标签包括 Python、Claude、开发工具。具体工具清单以官方文档为准。

Zabbix MCP Server A765fbbc 需要什么运行环境?

运行时为 Python;属于本地进程,需要在本机装好运行环境。

Zabbix MCP Server A765fbbc 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。