Core 354885a3

MCPAI代理

提供方 EngramAI-io

AI代理 未标注 Token 社区 / 第三方 Claude DesktopClaude

Sentinel是一款透明的MCP侧边车,提供身份、顺序和完整性保证,用于观察和记录LLM客户端与MCP工具之间的交互。

一句话选型结论

按资料字段整理

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

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

工具与能力

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

能力标签

支持客户端

适用场景

MCP协议Rust本地部署LLM工具链可观测性审计日志加密验证

安装与配置

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

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

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

多步任务编排

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

自动化重复流程

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

选择建议

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

值得选的地方

  • 已适配 Claude Desktop、Claude,换客户端不用重新研究配置。

先想清楚的地方

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

更适合

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

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Core 354885a3当前 未标注 未标注 未标注 无 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代理
字段来自项目仓库与公开索引,中文说明由本站标注
提供方EngramAI-io上游标注的维护方 EngramAI-io
分类AI代理本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式Token远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

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

Sentinel - The MCP Interceptor

> A transparent, fail-open observability sidecar for Model Context Protocol (MCP).
> Sentinel provides identity, ordering, and integrity guarantees for agent ↔ tool interactions - without modifying execution or coupling to agents.

Sentinel sits invisibly between an LLM client and its MCP tools, acting as a passive, non-blocking tap into live agent traffic. It does not alter requests. It does not gate execution. It does not impose policy.

Instead, Sentinel observes MCP traffic as it flows, reconstructs a canonical event stream, and exposes it to real-time visualization and durable audit logs.

The result:
You can finally see what your agent did, in what order, and trust the record afterward - even when the agent itself is a black box.


🚀 Try It Now (30 seconds)```bash

1. Install Sentinel

curl -fsSL https://raw.githubusercontent.com/EngramAI-io/sentinel/main/install.sh | sh

2. Run Sentinel in front of any MCP server

<your-mcp-client> sentinel run -- <your-mcp-server>

For example:

node mcp_client.js sentinel run --audit-log test_audit.jsonl -- node mcp_server.js

3. Open the dashboard

http://localhost:3000

---

&gt; ⚠️ **Project Status**
&gt; Sentinel is under active development. Core architecture and guarantees are implemented, with ongoing work on hardening, UX polish, documentation, and extended verification tooling.
&gt; Early adopters and reviewers are encouraged to provide feedback.

---

## What Sentinel Is (and Is Not)

**Sentinel is:**
- A transparent MCP sidecar
- A canonical event recorder
- A real-time observability layer
- A cryptographically verifiable audit tap

**Sentinel is not:**
- An execution engine
- A policy enforcer
- A tool broker
- A rate limiter
- A replay controller

Agents and tools continue to function **exactly the same** with or without Sentinel.

---

## Sentinel vs Official MCP Inspector

| Feature | Official MCP Inspector | Sentinel |
|------|-----------------------|----------|
| Primary Use | Isolated tool testing | Observing a **live agent** using tools |
| Integration | Separate web UI | Transparent sidecar in your workflow |
| Ordering | Implicit / undefined | **Canonical, monotonic event ordering** |
| Correlation | Per-request only | **Session, trace, and span continuity** |
| Auditability | None | **Append-only, signed, optional encrypted logs** |
| Failure Mode | Stops visibility | **Fail-open: execution continues** |

---

## Why Sentinel Exists

LLM agents reason implicitly.
Tool calls happen asynchronously.
Failures often appear *after* the cause.

Traditional logging breaks down.

Sentinel exists to provide **observability guarantees** that agent systems implicitly rely on but rarely formalize.

With Sentinel, you get:

- A single, ordered history of agent activity
- Request → response correlation across tools
- Latency and error visibility by method
- Durable logs you can replay and verify later
- A real-time graph that makes causality visible

Think **Chrome DevTools** -
but for **agent toolchains**.

---

## 🛡 Sentinel’s Core Guarantees

Sentinel provides **optional, non-invasive guarantees** around agent interactions.
When enabled, these guarantees support debugging, auditing, and security analysis.
When absent, agents continue to function normally - but these properties are lost.

---

### 1. Session Identity &amp; Trace Continuity

**Guarantee:**
Every observed agent action is causally attributable to a session and execution trace.

**Sentinel provides:**
- Stable `session_id` and `trace_id` for the lifetime of a run
- Per-request `span_id` with request ↔ response correlation
- Consistent attribution across tools and errors

**Without it:**
Logs become fragmented and reasoning becomes opaque.

---

### 2. Canonical, Ordered Event Stream

**Guarantee:**
There exists a single, consistent, replayable history of agent activity.

**Sentinel provides:**
- A monotonic, globally ordered event stream
- Append-only semantics
- Stable event IDs independent of wall-clock time

**Key property:**
Ordering is derived from **observation at the Sentinel boundary**, not timestamps.

**Without it:**
Events exist, but ordering is ambiguous and trust erodes.

---

### 3. Cryptographic Integrity of Telemetry

**Guarantee:**
Observed agent behavior has not been tampered with after the fact.

**Sentinel provides:**
- Hash-chained, append-only audit records
- Ed25519 digital signatures
- Optional encryption at rest
- Offline verification tooling

**Important:**
Cryptography applies **only to telemetry**, never to execution.

---

## Why These Guarantees Matter Together

| Property | Question Answered |
|--------|------------------|
| Identity | Who did what? |
| Order | In what sequence? |
| Integrity | Can we trust the record? |

Together, these form the minimum foundation required for **serious observability** - without enforcing policy or constraining agents.

---

## Design Philosophy

- Observe, never decide
- Record, never enforce
- Fail open, not closed
- Trust comes from visibility, not control

---

# ✨ Core Features

### 📡 Transparent MCP Sidecar
Drop Sentinel in front of any MCP server and instantly get deep visibility - no code changes, no rewrites, no patching.

### ⚡ Zero-Copy, Sub-Millisecond Proxying
Sentinel intercepts JSON-RPC traffic without buffering or mangling payloads. True pass-through with &lt;1ms overhead.

### 🧠 Real-Time Interactive Graph
Every tool call becomes a glowing edge.
Every response updates node stats.
Errors pulse red.
High-latency calls glow warm.

### 🔐 Built-in PII Redaction
Sensitive fields are scrubbed **only** in observability outputs.
Original MCP traffic is never modified.

### 💥 Fail-Open Guarantee
If the UI crashes or the WebSocket drops, **your MCP pipeline continues unfazed**.

### 🖥️ Claude Desktop Ready
One command patches Claude Desktop while preserving automatic backups.

---

# 🏗 Architecture

**Pattern:** Transparent Sidecar (T-Tap)
**Philosophy:** Fail Open
**Tech Stack:** Rust (Tokio) • TypeScript • React • React Flow • WebSockets```
                  ┌──────────────┐
                  │   LLM Agent  │
                  └──────┬───────┘
                         │
            responses ▲  │   ▼ requests
                         │
                  MCP (JSON-RPC over stdio)
                         │
            responses ▲  │   ▼ requests
                         │
                  ┌──────────────────┐
                  │     Sentinel     │  ← observe only (fail-open)
                  │  • parse MCP     │
                  │  • order events  │
                  │  • emit telemetry│
                  └──────┬───────────┘
                         │
            responses ▲  │   ▼ requests
                         │
                  unchanged MCP stream
                         │
            responses ▲  │   ▼ requests
                         │
                  ┌──────────────────┐
                  │   MCP Server /   │
                  │       Tools      │
                  └──────────────────┘


💎 Full Feature List

  • Zero-copy stdin/stdout MCP pass-through
  • Canonical event sequencing
  • Session / trace / span correlation
  • WebSocket event bus
  • Full JSON-RPC parsing
  • Per-method latency & error metrics
  • Interactive force-directed graph
  • Panic recovery & safe shutdown
  • NDJSON audit logs for tooling integration

🚀 Quick Installation

Option 1: Curl Install (Recommended)

Linux/macOS:```bash
curl -fsSL https://raw.githubusercontent.com/EngramAI-io/sentinel/main/install.sh | sh


**Custom install directory:**```bash
INSTALL_DIR=$HOME/.local/bin curl -fsSL https://raw.githubusercontent.com/EngramAI-io/sentinel/main/install.sh | sh

Option 2: Windows (PowerShell)```bash

iwr https://raw.githubusercontent.com/EngramAI-io/sentinel/main/install.ps1 -UseBasicParsing | iex


### Option 3: Download Pre-built Binary

Download the latest release for your platform:
- Linux x86_64
- macOS x86_64
- macOS ARM64 (M1/M2)
- Windows x86_64

---

After Download (Linux/macOS only):```bash
chmod +x sentinel-*
sudo mv sentinel-* /usr/local/bin/sentinel

📖 Usage & Documentation

Once Sentinel is installed, see the full usage guide for:

  • Running Sentinel with MCP servers
  • WebSocket authentication
  • Audit logging & encryption
  • Claude Desktop integration
  • Common deployment patterns
  • Troubleshooting

👉 Read the full guide:
📄 docs/USAGE.md


📚 Manual Build from Source

Step 1: Install Prerequisites

1.1 Install Rust and Cargo

On Windows:
1. Download and run the Rust installer by following the instructions at https://www.rust-lang.org/tools/install
2. Follow the installation prompts (defaults are recommended)
3. Restart your terminal/PowerShell after installation
4. Verify installation:powershell rustc --version cargo --version
You should see versions like rustc 1.70.0 or higher, and cargo 1.70.0 or higher.
5. If you're a Windows Subsystem for Linux (WSL) user, run the following in your terminal, then follow the on-screen instructions to install Rust.```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh


**On macOS:**```bash
# Install using Homebrew
brew install rust

# Or use rustup (recommended)
curl --proto &#x27;=https&#x27; --tlsv1.2 https://sh.rustup.rs -sSf | sh
source $HOME/.cargo/env

# Verify installation
rustc --version
cargo --version

On Linux:```bash

Install using rustup (recommended)

curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
source $HOME/.cargo/env

Verify installation

rustc --version
cargo --version


#### 1.2 Install Node.js and npm

**On Windows:**
1. Download Node.js from https://nodejs.org/
2. Choose the LTS version (18.x or higher recommended)
3. Run the installer and follow the prompts
4. Verify installation:```powershell
   node --version
   npm --version
   ```
   You should see `v18.x.x` or higher for Node.js, and `9.x.x` or higher for npm.

**On macOS:**```bash
# Using Homebrew
brew install node

# Verify installation
node --version
npm --version

On Linux:```bash

Install nvm (Node Version Manager)

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

Install Node.js using nvm

nvm install node

Verify installation

node --version
npm --version


### Step 2: Clone and Navigate to Project```bash
# If you haven&#x27;t already cloned the repository
git clone https://github.com/EngramAI-io/sentinel.git
cd sentinel

# Or if you&#x27;re already in the project directory, verify you&#x27;re in the right place
# You should see Cargo.toml and a frontend/ directory

Step 3: Build the Frontend

  1. Navigate to the frontend directory:bash cd frontend/my-react-flow-app

  2. Install frontend dependencies:bash npm install
    This will download and install all required packages (React, React Flow, Vite, TypeScript, etc.)

  3. Build the frontend for production:bash npm run build
    This compiles TypeScript, bundles the React app, and outputs to frontend/dist/ directory.

  4. Return to the project root:bash cd ..

Step 4: Build the Rust Binary

  1. Build the release version (optimized):bash cargo build --release

Note: The first build may take 5-10 minutes as it compiles all dependencies. Subsequent builds will be much faster.

  1. Verify the binary was created:
    - Windows: target\release\sentinel.exe
    - macOS/Linux: target/release/sentinel

  2. (Optional) Test that the binary runs:```bash
    # Windows
    .\target\release\sentinel.exe --help

# macOS/Linux
./target/release/sentinel --help
```

Step 5: Test Locally

Option A: Run with Development Build (Recommended for Testing)

  1. In one terminal, run the sentinel proxy with an MCP server:bash cargo run -- run -- npx -y @modelcontextprotocol/server-filesystem

This will:
- Start the sentinel proxy
- Launch the MCP filesystem server
- Start the HTTP/WebSocket server on port 3000

  1. Open your browser and navigate to:http://localhost:3000

  2. You should see the dashboard with:
    - A force-directed graph visualization
    - An "Agent" node in the center
    - Tool nodes appearing as MCP requests are made

  3. To test with a different MCP server:```bash
    # SQLite server example
    cargo run -- run -- npx -y @modelcontextprotocol/server-sqlite path/to/database.db

# Custom Python server example
cargo run -- run -- python -m my_mcp_server
```

Option B: Run with Release Binary

  1. Use the release binary you built:```bash
    # Windows
    .\target\release\sentinel.exe run -- npx -y @modelcontextprotocol/server-filesystem

# macOS/Linux
./target/release/sentinel run -- npx -y @modelcontextprotocol/server-filesystem
```

  1. Open http://localhost:3000 in your browser

Step 6: Verify Everything Works

  1. Check the dashboard loads: You should see the visualization interface
  2. Check WebSocket connection: The graph should be interactive
  3. Check logs: Look for sentinel_debug.jsonl in the project directory for debug logs
  4. Test interactivity: Click on nodes to see detailed JSON-RPC payloads

Troubleshooting

Issue: cargo: command not found
- Solution: Restart your terminal after installing Rust, or manually add ~/.cargo/bin to your PATH

Issue: npm: command not found
- Solution: Restart your terminal after installing Node.js, or verify Node.js is in your PATH

Issue: Frontend build fails
- Solution: Make sure you're in the frontend/ directory and run npm install first

Issue: Port 3000 already in use
- Solution: Kill the process using port 3000, or modify the port in the code

Issue: cargo build fails with linker errors (Windows)
- Solution: Install Microsoft C++ Build Tools from https://visualstudio.microsoft.com/visual-cpp-build-tools/

Issue: Binary not found after build
- Solution: Check that the build completed successfully. Look for target/release/sentinel (or .exe on Windows)

Install for Claude Desktop```bash

Install sentinel for a specific MCP server

./target/release/sentinel install filesystem

The config is automatically updated and backed up

Your Claude Desktop will now use sentinel as a proxy


To restore the original config:```bash
# Config backup is at: ~/.config/claude-desktop/claude_desktop_config.json.backup (Unix)
# or %APPDATA%/Claude/claude_desktop_config.json.backup (Windows)

Project Structure```

sentinel/
├── src/
│ ├── audit.rs # Audit log writer and lifecycle management
│ ├── audit_crypto.rs # Signing, hashing, and encryption logic for tamper-evident logs
│ ├── config.rs # Claude Desktop config helper
│ ├── decrypt_audit_log.rs # Signing, hashing, and encryption logic for tamper-evident logs
│ ├── events.rs # Event logging structures
│ ├── keygen.rs # Offline audit log verification and decryption
│ ├── main.rs # CLI and orchestration
│ ├── panic.rs # Panic recovery
│ ├── proxy.rs # Zero-copy stdio proxy
│ ├── protocol.rs # JSON-RPC structures
│ ├── parser.rs # NDJSON streaming parser
│ ├── session.rs # Request/response correlation
│ ├── server.rs # HTTP/WebSocket server
│ └── redaction.rs # PII redaction
└── frontend/ # React dashboard
└── src/
├── App.tsx
├── components/
│ ├── Graph.tsx
│ └── NodeDetails.tsx
└── hooks/
└── useWebSocket.ts


## Development

### Frontend Development```bash
cd frontend
npm install
npm run dev

This runs the frontend in dev mode (not embedded). To connect to a running sentinel instance, update the WebSocket URL in src/hooks/useWebSocket.ts.

Build Frontend for Embedding```bash

cd frontend
npm run build

Output goes to frontend/dist/ which gets embedded into the binary


## Usage Examples

### Example: MCP Filesystem Server```bash
# Development (no auth)
cargo run -- run -- npx -y @modelcontextprotocol/server-filesystem

# Production (with auth)
cargo run -- run --ws-token &quot;secret123&quot; --ws-bind &quot;127.0.0.1:3000&quot; -- npx -y @modelcontextprotocol/server-filesystem

Example: MCP SQLite Server```bash

cargo run -- run --ws-token "$SENTINEL_WS_TOKEN" -- npx -y @modelcontextprotocol/server-sqlite path/to/database.db


### Example: Custom Server with Audit Logging```bash
# First generate keys
cargo run -- keygen --out-dir ./keys
cargo run -- recipient-keygen --out-dir ./keys

# Run with full audit logging and encryption
cargo run -- run \
  --signing-key-b64-path ./keys/signing_key.b64 \
  --encrypt-recipient-pubkey-b64-path ./keys/recipient_pub.b64 \
  --audit-log ./audit.jsonl \
  --ws-token &quot;secret123&quot; \
  -- python -m my_mcp_server

Dashboard

The dashboard visualizes:
- Agent Node (center): The LLM client
- Tool Nodes (satellites): MCP servers and their methods
- Edges: Active communication paths
- Colors:
- Yellow = Pending request
- Green = Successful response
- Red = Error response

Click on any node to see detailed JSON-RPC payloads.

Debugging

  • Audit logs written to sentinel_audit.jsonl (configurable via --audit-log)
  • Panic logs go to sentinel_panic.log
  • Config backups are created automatically with .backup extension
  • Console output shows:
  • ✅ Success indicators (green checkmarks)
  • ❌ Error indicators (red X marks)
  • 🔒 Security status (lock icons)
  • ⚠️ Warnings (warning triangles)
  • 📝 Checkpoints and audit events

Security

🔒 Built-in Security Features

Sentinel is designed with security-first principles:

Authentication

  • WebSocket Token Authentication: Protect your observability endpoint with token-based auth
  • Environment Variable Support: Set SENTINEL_WS_TOKEN to avoid exposing tokens in command history
  • Automatic Warning: Sentinel warns when running without authentication in production```bash

Secure mode (recommended)

./sentinel run --ws-token "your-secret-token-here" -- npx @modelcontextprotocol/server-filesystem

Using environment variable (recommended for production)

export SENTINEL_WS_TOKEN="your-secret-token-here"
./sentinel run -- npx @modelcontextprotocol/server-filesystem

Connect from browser/client

ws://localhost:3000/ws?token=your-secret-token-here


#### **Configurable Network Binding**
- **Custom Bind Address**: Control where the WebSocket server listens
- **Production-Ready**: Bind to specific interfaces or use Unix sockets```bash
# Localhost only (default - most secure)
./sentinel run --ws-bind &quot;127.0.0.1:3000&quot; -- your-mcp-server

# All interfaces (use with authentication!)
./sentinel run --ws-bind &quot;0.0.0.0:3000&quot; --ws-token &quot;secret&quot; -- your-mcp-server

# Custom port
./sentinel run --ws-bind &quot;127.0.0.1:8080&quot; -- your-mcp-server

PII Redaction

  • API keys, tokens, emails automatically scrubbed before visualization
  • Original MCP traffic is never modified - redaction only applies to observability data
  • Regex-based detection with multiple pattern types:
  • api_key, apikey, access_token, secret_key
  • OpenAI-style sk-* keys
  • Email addresses
  • Bearer tokens

Cryptographic Audit Logging

  • Ed25519 Digital Signatures: Every checkpoint is cryptographically signed
  • ChaCha20-Poly1305 Encryption: Optional end-to-end encryption for audit logs
  • Tamper-Evident Chains: Hash-chained events prevent retroactive modification
  • Verifiable Logs: Independent verification with sentinel verify command```bash

Generate signing keypair

./sentinel keygen --out-dir ./keys

Generate encryption keypair (optional)

./sentinel recipient-keygen --out-dir ./keys

Run with audit logging

./sentinel run \
--signing-key-b64-path ./keys/signing_key.b64 \
--encrypt-recipient-pubkey-b64-path ./keys/recipient_pub.b64 \
--audit-log ./audit.jsonl \
-- your-mcp-server

Verify audit log integrity

./sentinel verify \
--log ./audit.jsonl \
--pubkey-b64-path ./keys/signing_pubkey.b64 \
--decrypt-recipient-privkey-b64-path ./keys/recipient_priv.b64
```

Graceful Shutdown

  • Signal Handling: CTRL+C triggers graceful shutdown
  • Flush Guarantees: All audit logs are flushed to disk before exit
  • Timeout Protection: 10-second timeout prevents hanging on shutdown
  • No Data Loss: Event buffers are drained completely

Secure Dependencies

  • Pinned Versions: All dependencies use specific versions (no wildcards)
  • Latest Security Patches: tokio-tungstenite 0.24 with all CVEs patched
  • Memory Safety: Pure Rust implementation with zero unsafe blocks
  • Crypto Libraries: RustCrypto audited implementations

Error Handling

  • Detailed Logging: Comprehensive error information for debugging
  • User-Friendly Messages: Generic error messages prevent information disclosure
  • Fail-Open Proxy: MCP traffic continues even if observability fails
  • Panic Recovery: Custom panic handler prevents crashes from affecting MCP pipeline

Security Best Practices

  1. Always use authentication in production environments
  2. Bind to localhost unless you need remote access
  3. Enable audit log encryption for sensitive environments
  4. Rotate keys periodically using the keygen commands
  5. Monitor logs for unauthorized access attempts
  6. Keep Sentinel updated to get latest security patches

Security Disclosure

Found a security issue? Please email security@engramai.io (or your contact) instead of opening a public issue.

Config Backups

  • Config backups are created automatically before any modifications
  • Backup location:
  • Linux/macOS: ~/.config/claude-desktop/claude_desktop_config.json.backup
  • Windows: %APPDATA%\Claude\claude_desktop_config.json.backup

License

MIT

常见问题

6 问
答案由本站依据条目字段整理,不引用上游原文
Core 354885a3 怎么安装?

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

Core 354885a3 怎么在 Claude Desktop、Claude 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Core 354885a3 收费吗?

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

Core 354885a3 需要 API Key 吗?

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

Core 354885a3 支持哪些客户端?

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

Core 354885a3 能提供哪些能力?

资料显示能力标签包括 可观测性、Rust、Claude、审计日志。具体工具清单以官方文档为准。

热门专题

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

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