Remem

MCP文档知识

提供方 未标注

文档知识 未标注 未标注 社区 / 第三方 ClaudeCursorVS CodeWindsurf

面向Claude Code和Codex的本地优先持久化记忆。钩子自动捕获会话,由LLM提炼至SQLite(可选SQLCipher加密),通过MCP、REST和CLI保持可审计的召回。单一Rust二进制文件。

一句话选型结论

按资料字段整理

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

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

工具与能力

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

能力标签

支持客户端

适用场景

记忆

安装与配置

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

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

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

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

值得选的地方

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

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Remem当前 未标注 未标注 未标注 无 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

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

详细介绍

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

remem: Local-first memory for Claude Code and OpenAI Codex

> Stop re-explaining your project every new coding-agent session.

Language: English | 简体中文

remem automatically captures, distills, searches, and injects engineering
memory across Claude Code and OpenAI Codex CLI sessions. Decisions,
bug-fix rationale, project patterns, and preferences stay available through
hooks, MCP, CLI, and a localhost REST API.

A new Claude Code session recalls the earlier root cause, commit, and open
TODO with memory citations and no re-explaining.

What remem gives you

  • Automatic session capture and background LLM distillation.
  • Project-scoped recall across Claude Code and Codex using one local store.
  • Searchable decisions, bug fixes, architecture notes, preferences, and raw
    session evidence.
  • Source attribution, staleness labels, suppression, review queues, and
    injection audits.
  • SQLite with SQLCipher encryption by default for fresh installs.
  • MCP, CLI, and authenticated localhost REST access from one Rust runtime.

remem prioritizes memory quality. Automatic capture is the primary path;
manual save_memory calls supplement it when a decision needs to be recorded
immediately.

Install in five minutes

Homebrew```bash

brew install majiayu000/tap/remem
"$(brew --prefix remem)/bin/remem" install --target codex


Use `--target claude` for Claude Code. `--target all` configures every known
host, including Cursor where its v1 renderer is supported.

### Standalone installer```bash
curl -fsSL https://raw.githubusercontent.com/majiayu000/remem/main/install.sh | env REMEM_NO_CONFIG=1 sh
~/.local/bin/remem install --target codex

npm or Cargo```bash

npm install -g @remem-ai/remem

or

cargo install remem-ai --bin remem

remem install --target codex


Codex installation, detection, doctor, uninstall, transcript scanning and
default native-memory import all honor `CODEX_HOME`; the default is
`~/.codex`. Set it to an absolute directory before running these commands
to select another Codex profile. Empty or relative overrides fail visibly
before installation writes. Unrelated profile files stay untouched.

GitHub Releases: prebuilt binaries for macOS and Linux on x64/arm64, with
published checksums. Use one canonical `remem` executable on `PATH`;
`remem doctor` warns when hooks and terminals resolve different copies.

For channel-specific upgrades, platform boundaries, PATH drift, and manual
install notes, read the installation and upgrade guide.
The broader documentation guide links plugin and operational
material.

## Verify the installation

Restart the selected coding agent, then run:```bash
remem doctor
remem status
remem search "last decision"

A healthy Claude Code or Codex installation injects relevant project memory at
SessionStart and queues durable session distillation at Stop. Codex also uses
UserPromptSubmit to capture each prompt and surface compact optional memory
candidates. remem doctor checks the schema, encryption key, database, hooks,
MCP registration, worker, and common install-path drift.
Its diagnostics do not create the data directory or write or rotate log files;
findings and stderr warnings remain visible, and existing log health is inspected.

Repository contributors can verify duplicate SessionStart suppression with the
isolated executable smoke fixture.

For a focused, read-only view of current-memory truth:```bash
remem doctor truth --cwd .


### Why wasn't something remembered?

Use one read-only report to follow capture, extraction, review, current validity,
and the latest recorded context run:```bash
remem doctor memory "original phrase" --cwd .
remem doctor memory --host codex-cli --source-root local \
  --project PROJECT_KEY --session-id SESSION_ID --json

Copy the exact selector from remem raw sessions --json. Use
--injection-run-id RUN_ID to inspect a specific destination context emission.
The source session and destination context run are distinct. Each evidence
source is bounded at 20 rows; omitted evidence is marked. Terminal output shows
retained source/status counts and three samples per source; --json includes
all retained evidence. A missing match or
per-item audit is unknown, not proof that capture failed or a guessed drop
reason. Query discovery combines raw search with literal stored-text matches;
try an original phrase or the exact session when a paraphrase finds no evidence.
See the diagnosis contract.

Remem helps an Agent continue work; Refine helps people inspect and reuse
knowledge; agent-sessions parses native source formats. Refine consumes Remem's
existing session references, content fingerprints and commit/session links
instead of collecting another transcript copy.

Host support

Capability Claude Code Codex CLI Cursor v1
MCP memory tools Yes Yes Yes on macOS/Linux
SessionStart injection Yes Yes Not supported
Automatic session memory Yes Yes, Stop-based and low-noise Not enabled by the v1 installer
Tool-event capture Installed hooks No high-frequency Bash hook by default Runtime command exists; no installed hook
Compiled command-rule enforcement Optional warn/block on Bash Not supported Not supported
Windows Supported Supported Not supported

Cursor's v1 installer registers MCP only. The verified observe and
summarize runtime commands exist, but remem install --target cursor does
not install automatic capture hooks or SessionStart injection.

The repository also includes a Codex plugin wrapper. See
plugins/remem/README.md for local plugin runtime and
explicit hook activation instructions.

Why use remem alongside built-in memory

Built-in MEMORY.md, CLAUDE.md, and agent instruction files are ideal for a
small set of stable facts that should always be visible. remem covers the
engineering history that is too large, dynamic, or evidence-heavy to maintain
by hand.

Need Built-in files remem
Stable project rules Excellent Supported
Evolving context Handwritten instructions; Claude Code auto memory also writes notes Hook-driven session capture and background distillation
Search older rationale Limited by loaded text Curated and raw search
Branch, time, and staleness handling Manual Built in
Provenance and injection audit Git history Database-backed audit
Review, suppression, and lifecycle governance Manual edits First-class commands

Claude Code auto memory already saves
notes automatically. The distinction is the memory surface and its evidence,
retrieval, and lifecycle controls, rather than automatic persistence alone.

Use both. Keep concise rules in native files and let remem retain the long tail
of decisions, failures, evidence, and changing project state.

The broader ecosystem comparison lives in the dated
memory-tool survey.

How it works```text

Claude Code / Codex hooks
|
v
append-only captured_events ledger
|
v
coalesced background extraction and session rollup
|
v
governed candidates -> curated memories + workstreams + raw archive
|
v
FTS, entity, temporal, vector, graph, and optional local rerank retrieval
|
v
budgeted, source-attributed SessionStart context


Hooks return quickly after durable capture or queueing. Background workers
perform extraction, candidate governance, compression, retrieval enrichment,
and lifecycle cleanup. MCP, CLI, REST, and SessionStart share the same local
store and governance model, but apply surface-specific eligibility policies.
Explicit search is an inspection and recovery surface, so it may return
labeled `legacy_unverified` memories; default SessionStart and CurrentTruth
exclude those rows and record the reason.

Malformed generated extraction responses retry with the existing bounded
backoff while keeping the same source evidence. Invalid stored evidence still
requires repair; exhausted model attempts preserve raw capture and replay
ranges for inspection instead of accepting incomplete output.

Observation extraction and session rollup split large backlogs into bounded
event chunks. Each model call budgets system instructions, prompt formatting,
and evidence together; completion advances only through the processed chunk.
Raw evidence remains available when per-event prompt content is clipped. Exact
recovery retains the original range and resumes verified successful chunks
under the explicitly selected profile and one overall timeout. Already-existing
linked successors resume from their own original bounds and checkpoints; a
completed primary task does not hide a failed successor. Archived exact recovery
claims the existing family atomically, suppresses new follow-up work, and archives
unfinished members again if the attempt fails.

Workers persist fair queue and stage/project claim order, so continuing capture
in a busy project leaves room for downstream extraction and durable jobs across
once-worker restarts. The existing once-worker admission budget still applies.

Generated memory is treated as untrusted until it passes source-support,
secret, instruction-pattern, scope, and lifecycle checks. Unsafe content is
dropped or routed to review with a diagnosable reason. Complete, user-supported
security prohibitions, research activities and explicitly analytical quotations
can enter human review in English or Chinese; they never auto-promote. Secret
values, harmful instructions and unsupported external text remain excluded.

Automatically promoted summary decisions and discoveries can enter current
context at their original summary confidence when captured local evidence,
the current summary gate, and the exact activation receipt still validate.
External content and missing or changed proof remain review-gated or excluded.
New trusted evidence can reconsider identical content that is still pending
review: remem preserves the original snapshot and links it to a fresh candidate.
Repeated evidence, human review decisions, quarantine, and suppression are
preserved. Expired operational state needs fresh evidence before renewal.

For module ownership and current data flow, read
docs/ARCHITECTURE.md.

The experimental MCP `context_bundle` tool exposes the versioned, budgeted
compiler to explicit callers. The experimental `remem context-plan` command
prints a request-specific retrieval plan. These opt-in interfaces are tracked
by the Context Bundle and
retrieval-router contracts.

The default Codex integration stays low-noise: `SessionStart` provides stable
context, `UserPromptSubmit` provides a compact candidate index, and `Stop`
queues background summarization. Prompt candidates contain IDs, titles,
state, retrieval reason, estimated read cost, and a detail lookup hint, but no
memory bodies. They are optional leads that Codex may ignore, open, or search
beyond. The first prompt may also receive up to two continuity anchors so a
prompt such as `continue` does not depend on lexical overlap. Existing hybrid
RRF ranks memory candidates; no final confidence threshold decides relevance
for the model. Automatic extraction asks for short, specific candidate titles
without a redundant project-name prefix; existing stored titles remain intact.

For your own Codex sidebar, an optional rename convention is
`MMDD|TYPE|Topic`, such as `0903|FIX|FTS5 tokenizer mismatch`. If you use a
separate host-supported rename workflow, preview its proposed names before
applying a batch. This is host-sidebar organization only: Remem does not rename
host conversations or import those names as intent overrides. Remem's structured
session/workstream fields remain authoritative, and a host title does not change
memory types or workstream identity. See the
session intent contract and
implementation epic #1065.

Session/workstream label corrections use authenticated
`POST /api/v1/session-intent/preview`, then explicit confirmation through
`POST /api/v1/session-intent/apply`. Keep each sensitive option or `Bearer`
prefix and its value on the same logical line in the proposed topic and reason.
For example, `curl --oauth2-bearer\nexample-value` is rejected with HTTP 400
`session_intent_cross_line_sensitive_argument`; put the option and value on one
line before retrying. Rejection creates no preview token or audit entry and
changes no labels. Same-line sensitive values are redacted before preview.

## Everyday workflows

### Recall and inspect```bash
remem search "database encryption"
remem search "deployment decision" --branch main --explain
remem show <memory-id>
remem why <memory-id>
remem current <state-key>

remem search keeps the terminal clean: per-query [INFO] [search-perf]
diagnostics are written to the log file, not stderr, in normal use. Set
REMEM_DEBUG=1 to mirror them to stderr while debugging.

Project aliases for Git worktrees

When a worktree has its own project key, preview an alias to the main checkout,
then apply it after checking the paths and Git proof:```bash
remem project alias add /path/to/worktree --canonical /path/to/main \
--actor you --reason "same project"
remem project alias add /path/to/worktree --canonical /path/to/main \
--actor you --reason "same project" --apply
remem project alias list
remem search "decision" --project /path/to/main
remem project alias revoke /path/to/worktree \
--actor you --reason "worktree retired" --apply


The main checkout must already have a project row from normal remem capture.
The alias keeps historical rows at their recorded paths while CLI and MCP
project searches include the worktree's memories. `add` and `revoke` preview
without database writes unless `--apply` is present. Revocation removes the
worktree from the main project's search scope; `list` reports active aliases
with the actor and reason from their latest activation.

Agents can use MCP `search` for compact results, then `get_observations` for
selected details. Use raw recall only when curated memory misses exact
transcript evidence:```bash
remem raw search "exact phrase" --since 2026-06-01 --json

List complete host-bound sessions before reading an exact transcript:```bash
remem raw sessions --latest 20 --json
remem raw messages --host codex-cli --source-root local \
--project "/path/to/project" --session-id SESSION_ID --json
remem ingest-sessions --root codex-cli:archive=/path/to/sessions --json


Default transcript scans use `$CLAUDE_CONFIG_DIR/projects` and
`$CODEX_HOME/sessions`, falling back to `~/.claude` and `~/.codex`.
An explicitly empty override is an error. Explicit override directories must exist
and be readable; only absent inferred defaults are skipped. Explicit `--root` directories remain
supported; descendant `subagents` directories are excluded from batch scans.
Codex session modes use native source evidence: IDE is interactive, explicit
`exec` is unattended even with a Desktop originator, and subagent evidence
takes precedence. These are source labels, not proof of who initiated a run.
Existing saved modes upgrade once after checking the original classification
evidence; genuine provenance conflicts still fail the batch. This adds schema
v093: retain a database backup before upgrading; older binaries cannot open
the upgraded schema. Raw message identities and cursors are preserved.

Copy `host`, `source_root`, `project`, and `session_id` unchanged from one
`raw sessions` summary into `raw messages`. Existing scripts must add the
required `--host` selector and replace `--root LABEL=PATH` with
`--root HOST:LABEL=PATH`; the same root format applies to `raw reconcile`.
The JSON envelope reports `excluded_legacy_rows`, `excluded_legacy_sessions`,
and `excluded_legacy_identities` when some archive rows cannot enter the
host-bound session contract. Each listed session also carries additive nullable
`mmdd`, `session_intent`, `session_topic`, `display_label`, and
`session_intent_source` fields. `mmdd` is derived from the session created epoch
in Asia/Shanghai; the full `{MMDD}|{INTENT}|{topic}` label is present only when
both intent and topic are known. Stop summaries may fill those fields with
source `summary`; unknown, empty, too-long, or redacted values abstain instead
of blocking the rest of the summary. Automatic Stop rollups preserve manual
label overrides, including explicit clears, across later turns. Listing still returns healthy sessions;
`--latest N` fills that bound from healthy sessions only and does not let
unresolved rows occupy those slots. Use the skipped identities (`source_root`,
`project`, `session_id`, and `host` when known) to inspect or repair those
rows. Exact `raw messages` for a skipped selector stays fail-closed. Do not
re-ingest a skipped row unless ingest can actually claim it — many legacy
rows have no trusted host provenance.
`HOST` is `claude-code` or `codex-cli`, and `LABEL` becomes the persisted
`source_root`. Cursor snapshot evidence requires a manually configured and
verified `remem summarize --host cursor` Stop integration; filesystem `--root`
ingestion and reconciliation reject `cursor` explicitly.

### Review and govern```bash
remem review list
remem review approve <candidate-id>
remem memory suppress memory:<id> --reason "no longer relevant"
remem govern --action stale --dry-run --json <id>

Mutating governance commands expose previews, explicit confirmations, or
review boundaries according to their risk. Run remem --help for
the current contract instead of relying on a copied command inventory.

MCP tools share that store with stricter wire contracts. The canonical MCP
contract is GH981, including the #1061
mutation and scope boundary:

  • save_memory: pass host when the calling host is known. An omitted host is
    recorded as unknown, never inferred as codex-cli.
  • govern_memory: dry-run first to preview IDs and current versions from that
    governance transaction. Non-dry-run mutations require expected_versions
    for every ID, confirm_destructive=true, and an explicit reason.
  • recall_user_context: supply project or cwd. The server does not infer
    this scope from its own process working directory.

The local Remem app
shows session/workstream labels or explicit abstention. Sessions can be filtered
by intent and created date in Asia/Shanghai. Operators can correct labels in
batches with a Before/After preview, explicit confirmation, and an audit;
workstream identity and host conversation titles stay stable.

Configure memory AI and retrieval```bash

remem config show
remem model current
remem model use balanced --dry-run
remem embedding status
remem embedding download --model multilingual-e5-small
remem embedding backfill --limit 1000


`auto` embedding mode stays local unless a remem-specific API key is selected.
The verified local model is optional; the labeled feature-hash fallback remains
available. The second-stage local reranker is also optional and disabled until
configured.

Vector indexes keep each model and artifact revision in its own vector space.
Project, branch, type, and lifecycle filters apply before nearest-neighbor
selection. Automatic context uses the same vector executor as search, so old
memories remain eligible by similarity as a project grows. While a derived
index is rebuilding, an exact local scan preserves recall; large stores may
take longer until that profile's index is ready.

Use the current configuration routes, the
local embedding contract, and
`remem config`, `remem embedding`, or `remem reranker` help for details.

`remem usage` reports every dispatched memory-AI attempt, including failures.
Observed zero, partial, missing, invalid, and text-estimated token counts remain
distinct. Reported USD is the known priced portion; coverage counts show when
unknown rates or missing counter details make it incomplete. Failed attempts
without provider counters do not receive guessed token estimates. Historical
usage remains labeled as unverified rather than being silently reclassified.

### Share or edit memory outside the database```bash
remem sync-memory --cwd .
remem export --markdown --output ./remem-memory
remem export --pack .remem-pack

Markdown mirrors are human-editable. Project memory packs are deterministic,
git-committable exports with provenance-aware import and quarantine behavior.
See the memory usage guide and
project memory pack contract.

Evidence and benchmarks

The checked-in public suite separates memory-system capability evidence from
coding-agent outcome evidence. Verify it locally with:```bash
cargo run -- bench verify --root eval/public --json-out /tmp/remem-bench-verify.json


Verification resolves `claims/registry.json` beside the parent of `--root`, so
an external bundle keeps `public/` and `claims/` as siblings and is independent
of the caller's working directory.

Public adversarial SQLite snapshots are capped at 64 MiB and must be canonical
`VACUUM` images; verifier-consumed artifact targets must also resolve inside the
declared public root.

The current public report does not support public benchmark claims and is
deliberately labeled
`directional_only_no_public_claim`. The historical isolated coding baseline is
useful engineering evidence, but its preloaded-memory condition is not
comparable with the current SessionStart retrieval path.

Reproduction commands, artifact schemas, claim boundaries, and current gates
live in:

- eval/README.md
- eval/public/README.md
- eval/coding-bench/README.md

README claims intentionally exclude unsealed local metrics that have no
checked-in report.

## Security and privacy

- Fresh installs create a SQLCipher-encrypted database and private key file.
- The data directory and key use restrictive per-user permissions.
- The REST API binds to `127.0.0.1` and requires a bearer token.
- Hook-captured event previews are redacted before durable storage.
- MCP and CLI workstream listings project redacted text: credential-like
  assignments, short inline secrets, and sensitive command options are replaced
  with `[REDACTED]` in returned fields (and CLI `--json` envelope `project`),
  while ordinary filesystem project paths stay readable. Stored workstream rows
  keep their canonical values for matching and scope checks, so queried output
  can differ from the database when secrets were present.
- Memory candidates and injected content pass secret and poisoning defenses.
- `remem doctor` reports encryption, plaintext residue, schema, and audit
  failures without printing memory payloads.

Read SECURITY.md for reporting and security policy. Operational
contracts for SQLite tuning and
memory-poisoning defense are
kept outside the landing page.

## REST API```bash
remem api --port 5567
TOKEN=$(cat ~/.remem/.api-token)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5567/api/v1/health
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5567/api/v1/capabilities

Clients should feature-detect through /api/v1/capabilities. The current
endpoint and compatibility contract is maintained in
docs/specs/SPEC-web-api.md.

Documentation

Use docs/README.md as the jump page for installation,
configuration, memory lifecycle, retrieval, governance, API, plugin,
operations, architecture, and benchmark material.

The most common destinations are:

  • Architecture and data flow
  • Memory usage guide
  • Memory lifecycle
  • Codex plugin
  • REST API contract
  • Current spec index
  • Changelog
  • Contributing

Uninstall

Preview and remove host hooks and MCP registration without deleting memory:bash remem uninstall --dry-run remem uninstall

The encrypted database remains in the configured REMEM_DATA_DIR. Back it up
before manually deleting that directory if data removal is intended. Ordinary
file deletion removes remem's local data but does not guarantee secure erasure
from filesystem snapshots, backups, or the underlying storage media.

License

MIT

常见问题

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

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

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

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

Remem 收费吗?

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

Remem 需要 API Key 吗?

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

Remem 支持哪些客户端?

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

Remem 能提供哪些能力?

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

热门专题

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

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