Z Kettle

MCPAI代理

提供方 benderterminal

AI代理 未标注 混合方式 社区 / 第三方

Self-hosted, zero-knowledge encrypted, self-destructing secrets for secure agent-to-agent coordination

一句话选型结论

按资料字段整理

Z Kettle 属于AI代理类 MCP 服务器,传输方式未标注,混合方式,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类AI代理 传输方式未标注 鉴权混合方式 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

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

能力标签

安装与配置

未标注 混合方式
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
给代理接外部能力

让代理在任务中途调用搜索、数据库等真实工具。

多步任务编排

把一串操作拆成步骤,由代理按顺序执行。

自动化重复流程

把固定流程交给代理跑,减少手工操作。

选择建议

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

值得选的地方

  • 基础信息齐全,可以先按官方文档接入试跑。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好混合方式对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在AI代理场景里让模型直接调用外部能力的人。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Z Kettle当前 未标注 未标注 未标注 无 2026-05-17
Filesystem 560c4363 13 未标注 本地部署 无 2026-05-17
Server Everything (everything) 11 stdio · 本地进程 本地部署 有 2026-05-17
Time 7365cb6d 2 SSE · 服务端推送 远程部署 有 2026-05-18
Everything Claude Code 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Openmemory 557e1585 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

AI代理
字段来自项目仓库与公开索引,中文说明由本站标注
提供方benderterminal上游标注的维护方 benderterminal
分类AI代理本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式混合方式远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

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

zKettle

Self-hosted zero-knowledge expiring secrets. Encrypt locally, store ciphertext on the server, share a URL with the decryption key in the fragment. The server never sees the plaintext or the key.

Installation

Go install (requires Go 1.25+)```bash

go install github.com/benderterminal/zkettle@latest


This installs to `$GOPATH/bin` (typically `~/go/bin`). Make sure it's in your PATH: `export PATH="$HOME/go/bin:$PATH"`

### Binary download```bash
curl -fsSL https://github.com/benderterminal/zkettle/releases/latest/download/zkettle-$(uname -s | tr A-Z a-z)-$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/') -o /usr/local/bin/zkettle && chmod +x /usr/local/bin/zkettle

From source```bash

git clone https://github.com/benderterminal/zkettle.git && cd zkettle && make install


### Via AI agent

Paste this prompt into Claude Code, Cursor, or any MCP-compatible agent:```
I want to set up zKettle — a self-hosted zero-knowledge secret sharing tool. Install it with go install github.com/benderterminal/zkettle@latest, then read the MCP setup instructions in the README at https://github.com/benderterminal/zkettle. When configuring the MCP server, use the absolute path to the installed binary (find it with which zkettle or check ~/go/bin/). Once configured, test the full workflow using the CLI: create a secret, read it back, and revoke it. Note that MCP servers are loaded at startup — the new tools won't be available until the next terminal session.

Quick Start```bash

Start the server with a Cloudflare tunnel (instant public URL)

zkettle serve --tunnel

Or start locally

zkettle serve --port 3000

Create a secret (in another terminal)

echo "my secret password" | zkettle create --views 1 --minutes 60

→ http://localhost:3000/s/abc123#key

Read a secret

zkettle read "http://localhost:3000/s/abc123#key"

→ my secret password (use -c for clipboard, -o <file> for file output)

Revoke a secret

zkettle revoke --server http://localhost:3000 --token <delete-token> <id>


Open the URL in a browser to reveal the secret via the web viewer.

## Docker Deployment```bash
# Build and run with Docker Compose
docker compose up -d

# Or build and run manually
docker build -t zkettle .
docker run -d -p 3000:3000 -v zkettle-data:/data zkettle

The container listens on port 3000 and stores data in /data. Configure with environment variables (see Configuration Reference).

Production Deployment

With TLS (direct)```bash

zkettle serve --host 0.0.0.0 --tls-cert /path/to/cert.pem --tls-key /path/to/key.pem


### With a reverse proxy (recommended)

Run zkettle behind Caddy, Nginx, or Traefik for automatic TLS:```bash
zkettle serve --host 127.0.0.1 --trust-proxy

Enable --trust-proxy so zkettle reads the real client IP from X-Forwarded-For headers.

Systemd

Copy the service template and enable it:```bash
sudo cp contrib/zkettle.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now zkettle


The service template uses `DynamicUser=yes` with `ReadWritePaths=/var/lib/zkettle`, so systemd manages the data directory automatically.

Configure via environment file at `/etc/zkettle/env`:```bash
ZKETTLE_PORT=3000
ZKETTLE_HOST=0.0.0.0
ZKETTLE_ADMIN_TOKEN=your-secret-token
ZKETTLE_TRUST_PROXY=true

Backups

The database is a single SQLite file at /zkettle.db. Back it up with:```bash
sqlite3 /var/lib/zkettle/zkettle.db ".backup /backups/zkettle-$(date +%Y%m%d).db"


## Admin API

Enable the admin endpoint by setting an admin token via environment variable:```bash
export ZKETTLE_ADMIN_TOKEN=my-secret-admin-token
zkettle serve

> Note: Passing --admin-token on the command line exposes the token in process listings (ps, /proc/*/cmdline). Prefer the environment variable or config file.

List active secrets```bash

Via CLI

zkettle list --server http://localhost:3000 --admin-token my-secret-admin-token

Via API

curl -H "Authorization: Bearer my-secret-admin-token" http://localhost:3000/api/admin/secrets


Returns metadata only (ID, views remaining, timestamps). No encrypted content or decryption keys are ever exposed.

### GET /api/admin/secrets

Returns 404 when no admin token is configured (endpoint disabled). Requires `Authorization: Bearer ` header.

Response (200):```json
[
  {
    &quot;id&quot;: &quot;abc123...&quot;,
    &quot;views_left&quot;: 2,
    &quot;expires_at&quot;: &quot;2024-01-02T03:04:05Z&quot;,
    &quot;created_at&quot;: &quot;2024-01-01T00:00:00Z&quot;
  }
]

Metrics

Enable the /metrics endpoint with the --metrics flag:```bash
export ZKETTLE_ADMIN_TOKEN=my-secret-admin-token
zkettle serve --metrics


The `/metrics` endpoint requires the admin token (`Authorization: Bearer ` header). Returns 404 when no admin token is configured.

Returns JSON metrics at `GET /metrics`:```json
{
  &quot;zkettle_secrets_active&quot;: 5
}

MCP Setup

zKettle includes an MCP server for use with Claude Desktop, Claude Code, or any MCP-compatible agent.

> Important: Use the absolute path to the zkettle binary. Many MCP clients do not inherit your shell's PATH, so a bare zkettle command will silently fail to start.

Add to your MCP client's configuration file:```json
{
"mcpServers": {
"zkettle": {
"command": "/absolute/path/to/zkettle",
"args": ["mcp", "--port", "3001", "--tunnel"]
}
}
}


Use `--tunnel` for public shareable URLs via Cloudflare Quick Tunnel (no account required). Omit it for local-only access. Use `--base-url https://your-domain.com` if you have a custom domain.

**Claude Code shortcut:**```bash
claude mcp add -s user zkettle -- /absolute/path/to/zkettle mcp --port 3001 --tunnel

Docker (for MCP verification/indexing):```bash
docker build -t zkettle-mcp .
docker run --rm -i -p 3000:3000 -v zkettle-data:/data zkettle-mcp


The container defaults to `zkettle mcp --host 0.0.0.0 --port 3000 --data /data`.

The MCP server starts an HTTP backend on the specified port and communicates with the agent over stdio. All encryption and decryption happens locally — in the browser (Web Crypto API), CLI, or MCP server process. The zKettle HTTP server never sees plaintext.

Available tools:

| Tool | Description |
|------|-------------|
| `create_secret` | Encrypt and store a secret (`content` or `file` input), returns an expiring URL |
| `read_secret` | Retrieve and decrypt a secret (`file` or `clipboard` output to avoid context exposure) |
| `list_secrets` | List active secrets (metadata only) |
| `revoke_secret` | Delete a secret by ID |
| `generate_secret` | Generate a random secret, optionally store it (`create=true`) |

## CLI Reference```
zkettle serve [options]     Start the HTTP server
  --port 3000               HTTP port
  --host 127.0.0.1          Listen address (use 0.0.0.0 for all interfaces)
  --data ./data             Data directory for SQLite database
  --base-url &quot;&quot;             Base URL for generated links (default: http://localhost:{port})
  --cors-origins &quot;&quot;         Comma-separated allowed CORS origins
  --tunnel                  Expose server via Cloudflare Quick Tunnel
  --trust-proxy             Trust X-Forwarded-For headers (behind a reverse proxy)
  --log-format &quot;&quot;           Log format: json or text (defaults to text)
  --tls-cert &quot;&quot;             TLS certificate file path
  --tls-key &quot;&quot;              TLS private key file path
  --admin-token &quot;&quot;          Admin API bearer token (enables GET /api/admin/secrets)
  --max-secret-size 0       Max encrypted secret size in bytes (0 = 500KB)
  --metrics                 Enable /metrics endpoint

zkettle create [options]    Encrypt and store a secret (reads from stdin)
  --views 1                 Max views before auto-delete
  --minutes 1440            Minutes until expiry (default 24h)
  --server http://localhost:3000   Server URL
  --json                    Output JSON to stdout
  --quiet, -q               Suppress stderr output

zkettle read [options] &lt;url&gt;   Retrieve and decrypt a secret (quote the URL)
  --clipboard, -c             Copy to clipboard instead of printing to stdout
  --file, -o &lt;path&gt;           Write to file (0600 permissions) instead of stdout

zkettle revoke [options] &lt;id&gt;   Delete a secret
  --server http://localhost:3000   Server URL
  --token &quot;&quot;                Delete token (returned by create, or set ZKETTLE_DELETE_TOKEN)

zkettle list [options]      List active secrets (requires admin token)
  --server http://localhost:3000   Server URL
  --admin-token &quot;&quot;          Admin API bearer token
  --json                    Output raw JSON

zkettle generate [options]  Generate a cryptographically random secret
  --length 32               Length in characters
  --charset alphanumeric    Character set: alphanumeric, symbols, hex, base64url

zkettle mcp [options]       Start MCP server on stdio with HTTP backend
  --port 3000               HTTP port for API
  --host 127.0.0.1          Listen address
  --data ./data             Data directory
  --base-url &quot;&quot;             Base URL for generated links
  --tunnel                  Expose server via Cloudflare Quick Tunnel
  --trust-proxy             Trust X-Forwarded-For headers (behind a reverse proxy)
  --log-format &quot;&quot;           Log format: json or text (defaults to text)

zkettle version             Print version

Configuration Reference

Configuration is resolved in order of precedence: flags > env vars > config file > defaults.

Config file

Search order: ./zkettle.toml, `$HOME/.config/zkettle/zkettle.toml````toml
port = 3000
host = "127.0.0.1"
data = "./data"
base_url = ""
cors_origins = []
trust_proxy = false
tunnel = false
log_format = "" # defaults to "text"
tls_cert = ""
tls_key = ""
admin_token = ""
max_secret_size = 0 # 0 = 500KB default
metrics = false


&gt; **Security:** If your config file contains `admin_token`, restrict permissions: `chmod 600 zkettle.toml`

### Environment variables

| Variable | Description |
|----------|-------------|
| `ZKETTLE_PORT` | HTTP port |
| `ZKETTLE_HOST` | Listen address |
| `ZKETTLE_DATA` | Data directory |
| `ZKETTLE_BASE_URL` | Base URL for generated links |
| `ZKETTLE_CORS_ORIGINS` | Comma-separated CORS origins |
| `ZKETTLE_TRUST_PROXY` | Trust proxy headers (`true`/`1`/`yes`) |
| `ZKETTLE_TUNNEL` | Enable Cloudflare tunnel (`true`/`1`/`yes`) |
| `ZKETTLE_LOG_FORMAT` | Log format: `json` or `text` |
| `ZKETTLE_TLS_CERT` | TLS certificate file path |
| `ZKETTLE_TLS_KEY` | TLS private key file path |
| `ZKETTLE_ADMIN_TOKEN` | Admin API bearer token |
| `ZKETTLE_MAX_SECRET_SIZE` | Max encrypted secret size in bytes |
| `ZKETTLE_METRICS` | Enable metrics endpoint (`true`/`1`/`yes`) |
| `ZKETTLE_DELETE_TOKEN` | Delete token for `zkettle revoke` (alternative to `--token`) |

## API Reference

### POST /api/secrets

Create a secret.

Request:```json
{
  &quot;encrypted&quot;: &quot;&lt;base64url ciphertext&gt;&quot;,
  &quot;iv&quot;: &quot;&lt;base64url 12-byte IV&gt;&quot;,
  &quot;views&quot;: 1,
  &quot;minutes&quot;: 1440
}

Constraints:
- encrypted — required, base64url-encoded, max 500KB decoded (configurable via --max-secret-size)
- iv — required, base64url-encoded, must decode to exactly 12 bytes
- views — 1-100 (default: 1)
- minutes — 1-43200 (default: 1440)

Response (201):```json
{
"id": "abc123",
"expires_at": "2024-01-02T03:04:05Z",
"delete_token": "def456"
}


Errors: 400 (validation), 415 (wrong Content-Type), 429 (rate limited)

### GET /api/secrets/{id}

Retrieve and consume a view. Returns the encrypted blob:```json
{
  &quot;encrypted&quot;: &quot;&lt;base64url ciphertext&gt;&quot;,
  &quot;iv&quot;: &quot;&lt;base64url IV&gt;&quot;
}

Errors: 400 (invalid ID format), 404 (expired, consumed, or nonexistent)

GET /api/secrets/{id}/status

Check availability without consuming a view.

Response (200):```json
{
"status": "available"
}


Errors: 400 (invalid ID format), 404 (expired, consumed, or nonexistent)

### DELETE /api/secrets/{id}

Delete a secret. Requires `Authorization: Bearer {delete_token}` header.

Response: 204 No Content

Errors: 400 (invalid ID format), 401 (missing token), 404 (not found or wrong token)

### GET /health

Health check. Returns 200 with `{&quot;status&quot;:&quot;ok&quot;}`, or 503 with `{&quot;status&quot;:&quot;error&quot;}` if the database is unavailable.

### GET /s/{id}

Serves the web viewer HTML. The decryption key is in the URL fragment (`#key`) and never sent to the server.

## Security Model

- **Zero-knowledge**: The server stores only AES-256-GCM ciphertext. The decryption key lives in the URL fragment, which browsers never send to the server.
- **Client-side encryption**: All encryption and decryption happens locally — in the browser (Web Crypto API), CLI, or MCP server process. The zKettle HTTP server never sees plaintext.
- **Expiring**: Secrets auto-delete after the configured number of views or time limit.
- **Composable library**: When importing zKettle as a Go library, use `ExtraRoutes` and `Middleware` to extend the server with custom routes and middleware for any deployment.
- **CLI/MCP plaintext exposure**: When reading secrets via CLI (`zkettle read`) or MCP (`read_secret`), the decrypted plaintext appears in terminal output or the MCP tool result (which enters the AI agent&#x27;s conversation context). To keep secrets out of terminal scrollback and agent logs, use `--clipboard` / `--file` (CLI) or the `clipboard` / `file` parameters (MCP). When creating secrets via MCP, use the `file` parameter to read content from a file, or `generate_secret` with `create=true` to generate and encrypt without exposing plaintext. In the web viewer, use the &quot;Copy Without Revealing&quot; button to copy a secret to clipboard without rendering it in the page.

## Building```bash
make build          # Build for current platform
make build-all      # Build for darwin/linux/windows amd64 + darwin/linux arm64
make install        # Build and install to $GOPATH/bin or /usr/local/bin
make test           # Run all tests
make clean          # Remove build artifacts

License

AGPL-3.0 — see LICENSE.

常见问题

5 问
答案由本站依据条目字段整理,不引用上游原文
Z Kettle 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Z Kettle 怎么在客户端里配置?

它的传输方式未标注,在客户端 MCP 配置里按官方文档填写启动命令和参数,保存后重启客户端生效。

Z Kettle 收费吗?

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

Z Kettle 需要 API Key 吗?

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

Z Kettle 能提供哪些能力?

资料显示能力标签包括 AI代理、工作流自动化、模型集成。具体工具清单以官方文档为准。

热门专题

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

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