Puzld

MCP办公协作

提供方 未标注

办公协作 stdio · 本地进程 未标注 社区 / 第三方 ClaudeCursorVS CodeGemini CLI
查看接入方式

Expose your local AI agent CLIs through one MCP endpoint Browse Puzld MCP Server for Claude, Cursor, VS Code, and other AI agents.

一句话选型结论

按资料字段整理

Puzld 属于办公协作类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude、Cursor、VS Code 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

Productivity

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
npx puzldai

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

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
日程与消息

查日程、发消息、约会议。

表单与审批

填表单、走审批流。

团队协作

同步任务、汇总进展。

选择建议

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

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Puzld当前 未标注 stdio · 本地进程 本地部署 有 未标注
CowAgent 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Karakeep MCP 未标注 未标注 未标注 无 2026-05-17
agentscope 未标注 stdio · 本地进程 本地部署 有 2026-04-11
note-gen 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Everywhere 未标注 stdio · 本地进程 本地部署 有 2026-04-12

服务器档案

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

详细介绍

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

Multi-LLM orchestration with agentic execution, memory, and training data generation.

Install •
Quick Start •
Features •
Config


> Beyond CLI wrappers. PuzldAI is a complete AI orchestration framework — route tasks, explore codebases, execute file edits, build memory, and generate training data.

PuzldAI is a terminal-native framework for orchestrating multiple AI agents. Route tasks to the best agent, compare responses, chain agents in pipelines, or let them collaborate. Agentic Mode gives LLMs tools to explore your codebase (view, glob, grep, bash) and propose file edits with permission prompts — like Claude Code, but for any LLM. Memory/RAG stores decisions and code for future context. Observation Layer logs everything for DPO fine-tuning. One framework that grows with your AI workflow.


Why PuzldAI?

Problem Solution
Claude is great at code, Gemini at research Auto-routing picks the best agent
Need specific model versions Model selection — pick sonnet, opus, haiku, etc.
Want multiple opinions Compare mode runs all agents in parallel
Complex tasks need multiple steps Pipelines chain agents together
Repetitive workflows Workflows save and reuse pipelines
Need agents to review each other Collaboration — correct, debate, consensus
Want LLM to explore & edit files safely Agentic mode — tools, permission prompts, apply
Context gets lost between sessions Memory/RAG — semantic retrieval of past decisions
Need data to fine-tune models Observations — export DPO training pairs
Need AI to understand your codebase Indexing — AST parsing, semantic search, AGENTS.md

Features

  • Auto-routing — Ask anything. The right agent answers.
  • Model Selection — Pick specific models per agent (sonnet, opus, haiku, etc.)
  • Compare — Same question, multiple agents, side-by-side.
  • Pipelines — Chain agents on-the-fly: gemini:analyze → claude:code (CLI)
  • Workflows — Save pipelines as templates, run anywhere (TUI & CLI)
  • Autopilot — Describe the goal. AI builds the plan.
  • Multi-Agent Collaboration — Correct, debate, and build consensus across agents.
  • Agentic Mode — LLMs explore your codebase, propose edits, you approve with permission prompts.
  • Codebase Indexing — AST parsing, semantic search, AGENTS.md support.
  • Memory/RAG — Semantic retrieval injects relevant context into prompts.
  • Observation Layer — Logs all interactions for training data generation.
  • Sessions — Persist chat history, resume conversations.
  • TUI — Full terminal UI with autocomplete, history, keyboard nav.

Supported Agents

Agent Source Requirement Agentic Mode
Claude Anthropic Claude CLI ✅ Full support
Gemini Google Gemini CLI ⚠️ Auto-reads files
Codex OpenAI Codex CLI ⚠️ Auto-reads files
Ollama Local Ollama running ✅ Full support
Mistral Mistral AI Vibe CLI ⚠️ Inconsistent

> Note: Some CLIs (Gemini, Codex) have built-in file reading that bypasses permission prompts. Claude and Ollama respect the permission system fully.


Install```bash

npm install -g puzldai


Or try without installing:```bash
npx puzldai

Update:```bash
npm update -g puzldai


---

## Quick Start```bash
# Interactive TUI
puzldai

# Single task
puzldai run "explain recursion"

# Compare agents
puzldai compare claude,gemini "best error handling practices"

# Pipeline: analyze → code → review
puzldai run "build a logger" -P "gemini:analyze,claude:code,gemini:review"

# Multi-agent collaboration
puzldai correct "write a sort function" --producer claude --reviewer gemini
puzldai debate "microservices vs monolith" -a claude,gemini
puzldai consensus "best database choice" -a claude,gemini,ollama

# Check what's available
puzldai check

> puzld also works as a shorter alias.


Interface


Execution Modes

Mode Pattern Use Case Category
Single One agent processes task Quick questions, simple tasks Basic
Compare Same task → multiple agents in parallel See different perspectives Parallel
Pipeline Agent A → Agent B → Agent C Multi-step processing Sequencing
Workflow Saved pipeline, reusable Repeatable workflows Sequencing
Autopilot LLM generates plan → executes Complex tasks, unknown steps AI Planning
Correct Producer → Reviewer → Fix Quality assurance, code review Collaboration
Debate Agents argue in rounds, optional moderator Find flaws in reasoning Collaboration
Consensus Propose → Vote → Synthesize High-confidence answers Collaboration
Agentic LLM explores → Tools → Permission prompts → Apply Codebase exploration + file edits Execution
Plan LLM analyzes task → Describes approach Planning before implementation Execution
Build LLM explores + edits with full tool access Direct implementation with tools Execution

Mode Options

Mode Option Type Default Description
Single agent AgentName auto Which agent to use
model string — Override model (e.g., sonnet, opus)
Compare agents AgentName[] — Agents to compare (min 2)
sequential boolean false Run one-at-a-time vs parallel
pick boolean false LLM selects best response
Pipeline steps PipelineStep[] — Sequence of agent:action
interactive boolean false Confirm between steps
Workflow name string — Workflow to load
interactive boolean false Confirm between steps
Autopilot planner AgentName ollama Agent that generates plan
execute boolean false Auto-run generated plan
Correct producer AgentName auto Agent that creates output
reviewer AgentName auto Agent that critiques
fixAfterReview boolean false Producer fixes based on review
Debate agents AgentName[] — Debating agents (min 2)
rounds number 2 Number of debate rounds
moderator AgentName none Synthesizes final conclusion
Consensus agents AgentName[] — Participating agents (min 2)
maxRounds number 2 Voting rounds
synthesizer AgentName auto Creates final output
Agentic agent AgentName claude Agent to use for exploration
tools string[] all Available tools (view, glob, grep, bash, write, edit)
Plan agent AgentName claude Agent to analyze task
Build agent AgentName claude Agent to implement

Model Selection

Pick specific models for each agent. Aliases like sonnet, opus, haiku always point to the latest version. Specific versions like claude-sonnet-4-20250514 are pinned.```bash

TUI

/model # Open model selection panel

CLI

puzldai model show # Show current models for all agents
puzldai model list # List all available models
puzldai model list claude # List models for specific agent
puzldai model set claude opus # Set model for an agent
puzldai model clear claude # Reset to CLI default

Per-task override

puzldai run "task" -m opus # Override model for this run
puzldai agent -a claude -m haiku # Interactive mode with specific model


---

## Compare Mode

Run the same prompt on multiple agents and compare results side-by-side.

Three views: **side-by-side**, **expanded**, or **stacked**.```bash
# TUI
/compare claude,gemini "explain async/await"
/sequential                    # Toggle: run one-at-a-time
/pick                          # Toggle: select best response

# CLI
puzldai compare "task"                          # Default: claude,gemini
puzldai compare "task" -a claude,gemini,codex   # Specify agents
puzldai compare "task" -s                       # Sequential mode
puzldai compare "task" -p                       # Pick best response

Pipeline Mode (CLI)

Chain multiple agents together for complex tasks. Each agent handles a specific step.```bash
puzldai run "build a REST API" -P "gemini:analyze,claude:code,gemini:review"
puzldai run "task" -P "claude:plan,codex:code" -i # Interactive: pause between steps


---

## Workflow Mode

Save pipelines as reusable templates. Run them anywhere with a single command.

Three views: **side-by-side**, **expanded**, or **stacked**.```bash
# TUI
/workflow code-review "my code here"
/workflows                     # Manage templates (interactive)
/interactive                   # Toggle: pause between steps

# CLI
puzldai run "task" -T code-review
puzldai run "task" -T code-review -i   # Interactive mode
puzldai template list            # List all templates
puzldai template show my-flow    # Show template details
puzldai template create my-flow -P "claude:plan,codex:code"
puzldai template delete my-flow  # Delete template

Autopilot Mode

Describe the goal. AI analyzes the task, builds a multi-step plan, and executes it automatically using the best agents for each step.

With /execute enabled, results display in 3 view modes: side-by-side, expanded, or stacked.```bash

TUI

/autopilot "build a todo app with authentication"
/planner claude # Set planner agent
/execute # Toggle auto-execution on/off

CLI

puzldai autopilot "task" # Generate plan only
puzldai autopilot "task" -x # Generate and execute
puzldai autopilot "task" -p claude # Use specific agent as planner


---

## Multi-Agent Collaboration

Get multiple agents to work together through correction, debate, or consensus.

### Correct Mode

One agent produces, another reviews. Optionally fix based on feedback.```bash
# TUI
/correct claude gemini "write a sorting algorithm"

# CLI
puzldai correct "task" --producer claude --reviewer gemini
puzldai correct "task" --producer claude --reviewer gemini --fix

Debate Mode

Agents debate a topic across multiple rounds. Optional moderator summarizes.```bash

TUI

/debate claude,gemini "Is functional programming better than OOP?"

CLI

puzldai debate "topic" -a claude,gemini
puzldai debate "topic" -a claude,gemini -r 3 -m ollama # 3 rounds + moderator


### Consensus Mode

Agents propose solutions, vote on them, and synthesize a final answer.```bash
# TUI
/consensus claude,gemini,ollama "best database for this use case"

# CLI
puzldai consensus "task" -a claude,gemini,ollama
puzldai consensus "task" -a claude,gemini -r 3 -s claude   # 3 rounds + synthesizer

All collaboration modes support 3 view modes: side-by-side, expanded, and stacked.

Configure rounds, moderator, and synthesizer in /settings.


Agentic Mode

LLMs explore your codebase using tools, then propose file edits with permission prompts (like Claude Code). PuzldAI acts as the execution layer — the LLM explores and proposes, you approve what gets executed.```bash

TUI - Use @agent syntax to trigger agentic mode

@claude fix the bug in src/utils.ts
@gemini add error handling to api/routes.ts
@ollama create a hello world script

Or use commands

/plan @claude refactor the auth system # Plan only (no execution)
/build @claude implement the login form # Full implementation with tools


**Tools available to LLM:**

| Tool | Description |
|------|-------------|
| `view` | Read file contents with line numbers |
| `glob` | Find files by pattern (e.g., `**/*.ts`) |
| `grep` | Search file contents with regex |
| `bash` | Execute shell commands |
| `write` | Create or overwrite files |
| `edit` | Search and replace in files |

**Permission prompts (like Claude Code):**
- `Allow` — Execute this tool call
- `Allow from directory` — Auto-approve reads from this directory
- `Allow all reads` — Auto-approve all file reads
- `Deny` — Skip this tool call
- `Esc` — Cancel entire operation

**Live tool activity:**
- Colored status dots: ● green (done), yellow (running), red (error), gray (pending)
- Tree-style result display with truncation
- `Ctrl+S` to expand/collapse full output

**How it works:**
1. You describe the task with `@agent`
2. LLM explores codebase using tools (view, glob, grep)
3. Each tool call shows a permission prompt
4. LLM proposes file edits (write, edit)
5. You approve or deny each change
6. PuzldAI applies approved changes

**Consensus → Agentic workflow:**
Run consensus first, then continue with an agent. The consensus result is automatically injected as context:```bash
/consensus claude,gemini "best approach for auth"
# Choose "Continue"
@claude implement this    # Has consensus context

Memory & Context

PuzldAI includes a memory system that stores conversations, decisions, and code patterns for future retrieval.

Memory types:
- conversation — Q&A pairs from sessions
- decision — Accepted file edits and explanations
- code — Code snippets and patterns
- pattern — Reusable solutions

How it works:
- Observations from /agentic are automatically saved to memory
- When you accept file edits, the decision is stored for future context
- Semantic search retrieves relevant memories for new prompts
- Uses SQLite FTS5 (zero dependencies) or Ollama embeddings when available

Embedding models (auto-detected):
- nomic-embed-text (recommended)
- mxbai-embed-large
- all-minilm


Observation Layer

All /agentic interactions are logged for training data generation:

  • Inputs: Prompts, injected context, agent/model used
  • Outputs: LLM responses, proposed files, explanations
  • Decisions: Which files were accepted/rejected
  • Edits: User modifications to proposed content

Export for fine-tuning:```typescript
import { exportObservations, exportPreferencePairs } from 'puzldai/observation';

// Export all observations as JSONL
exportObservations({ outputPath: 'observations.jsonl', format: 'jsonl' });

// Export DPO training pairs (chosen vs rejected)
exportPreferencePairs({ outputPath: 'preferences.jsonl', format: 'jsonl' });


**DPO pair types:**
- `accept_reject` — User accepted some files, rejected others
- `user_edit` — User modified the LLM's proposed content
- `full_reject` — User rejected all proposed files

---

## Codebase Indexing

Index your codebase for semantic search and automatic context injection.```bash
# TUI
/index                    # Open indexing panel
/index search "auth"      # Search indexed code

# CLI
puzld index               # Index current directory
puzld index --quick       # Skip embeddings (faster)
puzld index --search "handleLogin"
puzld index --context "fix auth bug"
puzld index --config      # Show detected config files
puzld index --graph       # Show dependency graph

What gets indexed:
- Functions, classes, interfaces, types
- Import/export relationships
- File dependencies with tsconfig path alias support

Project instructions (auto-injected into prompts):
- AGENTS.md — Project-wide instructions
- CLAUDE.md, CODEX.md — Agent-specific instructions
- .cursorrules, copilot-instructions.md — IDE rules
- .puzldai/agents/*.md — Per-agent instructions

When you run /agentic, project instructions are automatically injected into the prompt.


Commands

TUI Mode```

/compare claude,gemini "task" Compare agents side-by-side
/autopilot "task" AI-planned workflow
/workflow code-review "code" Run saved workflow
/workflows Manage templates

/correct claude gemini "task" Cross-agent correction
/debate claude,gemini "topic" Multi-agent debate
/consensus claude,gemini "task" Build consensus

@claude "task" Agentic mode with Claude
@gemini "task" Agentic mode with Gemini
/plan @claude "task" Plan mode (analyze, no execution)
/build @claude "task" Build mode (full tool access)

/index Codebase indexing options
/index search "query" Search indexed code

/session Start new session
/resume Resume previous session
/settings Open settings panel
/changelog Show version history

/agent claude Switch agent
/model Model selection panel
/router ollama Set routing agent
/planner claude Set autopilot planner
/sequential Toggle: compare one-at-a-time
/pick Toggle: select best from compare
/execute Toggle: auto-run autopilot plans
/interactive Toggle: pause between steps
/help All commands


### CLI Mode```bash
puzldai                           # Launch TUI
puzldai run "task"                # Single task
puzldai run "task" -a claude      # Force agent
puzldai run "task" -m opus        # Override model
puzldai run "task" -P "..."       # Pipeline
puzldai run "task" -T template    # Use template
puzldai run "task" -i             # Interactive: pause between steps
puzldai compare "task"            # Compare (default: claude,gemini)
puzldai compare "task" -a a,b,c   # Specify agents
puzldai compare "task" -s         # Sequential mode
puzldai compare "task" -p         # Pick best response
puzldai autopilot "task"          # Generate plan
puzldai autopilot "task" -x       # Plan + execute
puzldai autopilot "task" -p claude # Use specific planner
puzldai correct "task" --producer claude --reviewer gemini
puzldai correct "task" --producer claude --reviewer gemini --fix
puzldai debate "topic" -a claude,gemini -r 3 -m ollama
puzldai consensus "task" -a claude,gemini -r 3 -s claude
puzldai session list              # List sessions
puzldai session new               # Create new session
puzldai check                     # Agent status
puzldai agent                     # Interactive agent mode
puzldai agent -a claude           # Force specific agent
puzldai agent -m sonnet           # With specific model
puzldai model show                # Show current models
puzldai model list                # List available models
puzldai model set claude opus     # Set model for agent
puzldai model clear claude        # Reset to CLI default
puzldai serve                     # API server
puzldai serve -p 8080             # Custom port
puzldai serve -w                  # With web terminal
puzldai template list             # List templates
puzldai template show <name>      # Show template details
puzldai template create <name> -P "..." -d "desc"
puzldai template edit <name>      # Edit template
puzldai template delete <name>    # Delete template
puzldai index                     # Index codebase
puzldai index --quick             # Skip embeddings
puzldai index --search "query"    # Search indexed code
puzldai index --context "task"    # Get relevant context
puzldai index --config            # Show project config

Configuration

`~/.puzldai/config.json````json
{
"defaultAgent": "auto",
"fallbackAgent": "claude",
"routerModel": "llama3.2",
"adapters": {
"claude": { "enabled": true, "path": "claude", "model": "sonnet" },
"gemini": { "enabled": true, "path": "gemini", "model": "gemini-2.5-pro" },
"codex": { "enabled": false, "path": "codex", "model": "gpt-5.1-codex" },
"ollama": { "enabled": true, "model": "llama3.2" },
"mistral": { "enabled": true, "path": "vibe" }
}
}


---

## Architecture```
User Input (@claude "fix bug")
    │
    ▼
┌─────────┐     ┌────────────┐     ┌──────────┐
│ CLI/TUI │────▶│ Orchestrator│────▶│ Adapters │
└─────────┘     └────────────┘     └──────────┘
                      │                  │
        ┌─────────────┼─────────────┐    │
        ▼             ▼             ▼    ▼
 ┌───────────┐ ┌───────────┐ ┌──────────────┐
 │  Router   │ │  Memory   │ │   Agents     │
 │ (Ollama)  │ │  (RAG)    │ │ Claude       │
 └───────────┘ └───────────┘ │ Gemini       │
        │             │      │ Codex        │
        ▼             ▼      │ Ollama       │
 ┌───────────┐ ┌───────────┐ │ Mistral      │
 │ Indexing  │ │Observation│ └──────────────┘
 │ (AST/FTS) │ │  Logger   │
 └───────────┘ └───────────┘
        │             │
        ▼             ▼
 ┌───────────────────────────────┐
 │        Agent Loop             │
 │  LLM ──▶ Tool Call ──▶ Result │
 │   ▲           │          │    │
 │   │     ┌─────▼─────┐    │    │
 │   │     │ Permission│    │    │
 │   │     │  Prompts  │    │    │
 │   │     └───────────┘    │    │
 │   └──────────────────────┘    │
 └───────────────────────────────┘
        │             │
        ▼             ▼
 ┌───────────┐ ┌───────────┐
 │   Diff    │ │  Export   │
 │  Review   │ │  (DPO)    │
 └───────────┘ └───────────┘

Authentication & Privacy

PuzldAI doesn't handle your AI credentials directly. Instead, it orchestrates the official CLI tools you already have installed:

What PuzldAI Does What PuzldAI Doesn't Do
Calls claude, gemini, codex binaries Store your API keys
Passes prompts, receives responses Handle OAuth flows
Respects each CLI's auth state Piggyback on private OAuth clients

Why this matters:

  • No credential exposure — Your tokens stay with the official CLIs
  • No piggybacking — We don't borrow OAuth client IDs or reverse-engineer auth endpoints
  • No terms violations — We use CLIs exactly as their creators intended
  • Always up-to-date — When CLIs update their auth, you get it automatically
  • Your auth, your control — Log in once per CLI, PuzldAI just orchestrates

Some tools bypass official CLIs to call APIs directly using piggybacked credentials or unofficial OAuth flows. PuzldAI takes a different approach: we wrap the tools you trust, nothing more.


Development```bash

git clone https://github.com/MedChaouch/Puzld.ai.git
cd Puzld.ai
bun install
bun run build
npm link
puzldai
```


Contributing

Pull requests welcome! Please ensure your changes pass the build before submitting.


License

AGPL-3.0-only — See LICENSE


Built by Med Chaouch

常见问题

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

在客户端按下面的安装命令接入:npx puzldai。装完在客户端配置里引用同一个包或端点。

Puzld 怎么在 Claude、Cursor、VS Code 里配置?

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

Puzld 收费吗?

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

Puzld 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

Puzld 支持哪些客户端?

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

Puzld 能提供哪些能力?

资料显示能力标签包括 Productivity。具体工具清单以官方文档为准。

Puzld 需要什么运行环境?

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

Puzld 是本地还是远程?

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

热门专题

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

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