PADAM NOCTURNE

MCP文档知识

提供方 未标注

文档知识 stdio · 本地进程 API Key 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

AI 代理的本地记忆,存储在一个 SQLite 文件中:屏蔽机密信息,为所有者保留已识别的订单,并将搜索结果隔离为数据。HOL 合作伙伴。

一句话选型结论

按资料字段整理

PADAM NOCTURNE 属于文档知识类 MCP 服务器,stdio · 本地进程,API Key,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 API Key
客户端在本机拉起子进程,数据不出本机
claude mcp add padam -- uvx padam-nocturne

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

  1. 1
    准备运行环境

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

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

知识库读写

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

内容整理

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

选择建议

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

值得选的地方

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

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
PADAM NOCTURNE当前 未标注 stdio · 本地进程 本地部署 有 2026-11-20
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

服务器档案

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

详细介绍

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

PADAM · NOCTURNE

Memory for AI agents that sleeps, forgets honestly, and can be verified forever

One-click install: Install in Cursor · Install in VS Code · CLI: padam setup --all

Your agent reads a web page today and treats it as memory tomorrow. PADAM keeps that memory in one local SQLite file and makes it safe to read back:

  • an order hidden in a page can be held for you instead of becoming an instruction (PADAM_STRICT=1 holds every agent write for your review);
  • API keys and passwords are masked before they reach the disk;
  • what comes back is fenced as data, and a forgotten record is wiped from the file; if it was sent to Arweave, destroying its own key leaves only unreadable ciphertext there.

Measured, not claimed: seven red-team rounds with their results published (the sets of rounds 1–3 in full; rounds 4–7 were hashed before each run, their sets will follow after a read for real names), LongMemEval-S retrieval 97.0 % in the top 5 and 99.2 % in the top 10, against 96.0 % and 97.7 % for plain BM25, 968 tests and public CI. Listed in the HOL Guard catalog and the official MCP registry.

Security reviewers: start at docs/SECURITY_REVIEW.md — what we claim, every Red Team round and its results, what still gets through, and a ten-minute check.

PADAM is a local-first, persistent memory for AI assistants and agents. It lives in one SQLite file on your machine, plugs into any MCP client (Claude Code, Claude Desktop, Cursor, VS Code) or into your own code through a CLI and a small REST API.

NOCTURNE is its consolidation cycle — a "sleep" that turns a raw stream of episodes into lasting memory: it keeps what matters, folds repeats into the record they repeat, turns refinements and contradictions into a new version of it (the old one stays in history) and lets the rest fade, without letting rare dramatic events take the memory over.

L3 is the optional eternal layer. It anchors memory to Arweave (encrypted bundles) and Solana (a Merkle root in a Memo), so anyone can check that an anchored snapshot was not changed afterwards — while any single record can still be forgotten for good. Since 0.4.12 each bundle is also timestamped in Bitcoin through OpenTimestamps (free, no account): a second, independent witness. The .ots file lies next to the bundle, padam l3-ots-upgrade fetches the block height once it is mined, and padam l3-verify shows it.

Part of CODE Eternal · Project page: aifa.works/nocturne · Specification: English · Русский · Languages: English · Русский · Español · 中文


Contents

  • Why it exists
  • Three ideas that make it different
  • How it works
  • Quick start
  • Plug it into your agent — MCP, REST, CLI
  • Record kinds and how they fade
  • Search
  • The NOCTURNE cycle
  • L3 — the eternal, verifiable layer
  • Security model
  • Configuration
  • Tests
  • LongMemEval — measured on a public benchmark
  • Red Team Challenge
  • Honest limits
  • Cite, contribute, report
  • License

Why it exists

Agent memory today mostly accumulates. After a month it holds thousands of records; old decisions argue with new ones, and the agent answers from things that were abandoned long ago. A fact that was wrong but keeps being retrieved looks as fresh as the day it was written. And when a user asks to be forgotten, the usual answer is either "we can't — it's in the log" or "we deleted everything".

NOCTURNE does the night work a brain does: keep what matters, fold repeats into what it already holds, turn refinements into new versions, let the rest fade — and keep an honest history of every change. L3 adds what a private database cannot: proof, checkable by anyone, that each anchored snapshot was not changed afterwards. It does not prove that every memory was anchored or that a memory is true.

Three ideas that make it different

  1. Four limiters against "a memory made only of disasters." Prioritised replay over-samples rare sharp episodes, so memory drifts towards catastrophes. NOCTURNE corrects for rarity, caps the sharp share, blunts what was already replayed and keeps a floor for routine. On a synthetic buffer (1,000 ordinary + 612 catastrophic episodes) plain prioritised sampling gives catastrophes 90.7 % of the probability mass — about 181 of a 200-episode batch; with the limiters it is 50 of 200 (share 0.25). Re-measured from scratch on 8 Oct 2026; reproduce with python -m pytest tests/test_nocturne.py -k nightmare -q. Synthetic test — tune the limits on your own stream.
  2. Two clocks per record. last_seen_at changes when a record is shown, last_confirmed_at only when it is confirmed — and decay is computed from the second. A confidently wrong fact that keeps being retrieved does not stay "forever young".
  3. Nothing is deleted, yet forgetting is real. A contradiction creates a new version; the old one leaves search results but stays in history (timeline). forget wipes the content and destroys the record's own key, so its ciphertext on Arweave becomes noise forever, while the rest of the memory stays intact.
Typical agent memory PADAM · NOCTURNE
Growth accumulates without limit consolidated nightly: keep, merge, fade
Rare dramatic events crowd out routine capped share + floor for routine
A wrong fact that keeps being retrieved stays fresh fades — age counts from the last confirmation
Contradictions overwrite or pile up new version; old one kept in history
"Forget me" impossible or all-or-nothing one record, by destroying its own key
Where it lives vendor's cloud one SQLite file you own
Proof an anchored snapshot was not changed — Merkle root on Solana, ciphertext on Arweave

PADAM vs. unprotected agent memory (checked against 10 public READMEs, 14 Nov 2026)

Every competitor row below cites its own public GitHub README as of 14 Nov 2026 ("not stated in README" means the feature is not described in that repository's README on that date; we did not run third-party closed backends). Every PADAM claim links directly to the test or benchmark in this repository that verifies it.

System (public README) Holds injected orders for owner review + data fence Masks API keys, Solana wallets & cards before disk Single-record crypto-shredding + deletion receipt Public immutability proof (Merkle root + Bitcoin OTS) Two clocks (last_seen_at vs last_confirmed_at) Owner signature on identity / preference + Shamir legacy
mem0 Not stated in README Not stated in README Not stated in README Not stated in README Not stated in README Not stated in README
Zep / Graphiti Graphiti README explicitly notes reference servers do not detect or block prompt injection Not stated in README Not stated in README Not stated in README Bi-temporal validity windows on graph edges; no confirmation-only decay clock Not stated in README
Letta Not stated in README Not stated in README Not stated in README Not stated in README Not stated in README Not stated in README
Supermemory Not stated in README Not stated in README Not stated in README Not stated in README Auto-forgetting of outdated facts; no two-clock confirmation split in README Not stated in README
Basic Memory Not stated in README Not stated in README Local Markdown files; no per-record key destruction receipt Not stated in README Not stated in README Not stated in README
mcp-memory-service Not stated in README Not stated in README Not stated in README Not stated in README Autonomous decay consolidation; no two-clock confirmation split in README Not stated in README
cognee Not stated in README Not stated in README Not stated in README Not stated in README Not stated in README Not stated in README
Caura Agent trust levels (0–3); no held-write owner queue for prompt injection in README Flags PII (contains_pii); pre-disk secret masking not stated in README Not stated in README Not stated in README Not stated in README Not stated in README
SAIHM Not stated in README Client-side encryption; pre-encryption secret masking not stated in README States crypto-shredding in cloud (notes derived data cleanup is client's responsibility; PADAM forget --with-derived automates it) States accounting in COTI network Not stated in README Not stated in README
Mnemoverse Not stated in README Not stated in README Not stated in README Not stated in README Not stated in README Not stated in README

How it works```mermaid

flowchart TB
A[Agent / MCP client / CLI / REST] -->|write · search · confirm · refute| P[(PADAM<br/>SQLite)]
A -->|log episodes| B[Episode buffer]
B -->|python -m padam sleep| N[NOCTURNE<br/>consolidation]
N -->|keep · merge · fade · version| P
P -->|python -m padam l3| E[Per-record AES-256-GCM<br/>encryption]
E -->|ciphertext bundle| AR[(Arweave)]
E -->|Merkle root in a Memo| SOL[(Solana)]
AR --> V[l3-verify:<br/>recompute root]
SOL --> V


Three layers, one memory:

| Layer | What it holds | Where |
|---|---|---|
| **L1 — working** | the current conversation and the episode buffer | in the agent and in PADAM&#x27;s buffer |
| **L2 — consolidated** | records with kind, importance, two clocks and versions; words, BM25, identifiers and (optionally) neural embeddings | one local SQLite file |
| **L3 — eternal** (optional) | encrypted record bundles and forget receipts; a Merkle root per anchoring | Arweave + Solana |

---

## Quick start```bash
git clone https://github.com/MaksimGalatin/padam-nocturne &amp;&amp; cd padam-nocturne
pip install -e .            # numpy, requests, cryptography — Python 3.10+
python -m padam remember &quot;Answer in Russian, no filler words&quot; --kind preference --importance 1.0
python -m padam recall &quot;which language to answer in&quot; --explain
python -m padam log &quot;today we debugged the billing&quot;; python -m padam sleep
python -m padam stats

The CLI answers in English or Russian, following the system language; force one with PADAM_LANG=en or PADAM_LANG=ru. MCP answers are always in English — they are read by the model.

One memory for all your tools (MCP):```bash
claude mcp add padam -- uvx padam-nocturne


One click in Cursor or VS Code (needs uv):

From PyPI: `pip install padam-nocturne`. The latest code straight from GitHub: `uvx --from git+https://github.com/MaksimGalatin/padam-nocturne padam-nocturne`. Installed with `pip install -e .`? Then simply `claude mcp add padam -- padam-mcp`. Ready-made configs for **Claude Code, Claude Desktop, Cursor, VS Code, Codex, Gemini CLI, Windsurf, and Zed**, plus systemd and cron, are in `integrations/`. End-to-end stdio compatibility across all 8 MCP client configs is verified with `python scripts/check_integrations.py` (**8/8 passed**, 2026-11-15).

**LangChain.** Through `langchain-mcp-adapters` the nine tools become LangChain tools with their argument schemas. `python integrations/langchain_check.py` starts `uvx padam-nocturne` from PyPI (or a local path passed as argv[1]) and checks, with no language model: the tool list, a write found by search inside the fence, an injected order held for the owner, a secret that never reaches the database file (read as raw bytes). Verified on the 9-tool build with `langchain-mcp-adapters 0.3.2`, `langchain-core 1.8.0`, `mcp 1.30.0`: 6 of 6 (14 Nov 2026; earlier run on `0.4.8` with 8 tools and `langchain-core 1.7.7`: 6 of 6). One difference to know: the adapter passes a tool error (`isError: true`, e.g. `limit must be at most 50`) to the agent as ordinary text, not as a `ToolException`.

**CrewAI.** Through `MCPServerAdapter` from `crewai-tools` the MCP tools become CrewAI tools. `python integrations/crewai_check.py` starts `uvx padam-nocturne` from PyPI (or a local path) and runs the same checks with no language model: the tool list, a write found by search inside the fence, an injected order held for the owner, a secret that never reaches the database file. The current MCP server exposes 9 tools; the last run `5 of 5` was measured on **0.4.18 (8 tools)** with `crewai` and `crewai-tools 1.15.41`, `mcp 1.30.0` (14 Nov 2026). CrewAI needs Python below 3.14.

---

## Plug it into your agent — MCP, REST, CLI

### MCP server (stdio)

`padam-mcp` (the same program is also installed as `padam-nocturne`; `python -m padam.mcp_server` works too). The server speaks both eras of the protocol in one process: **2026-07-28** without a handshake (version and client capabilities in every request&#x27;s `_meta`, `server/discover`, `resultType` in every result, cacheable `tools/list` with `ttlMs` and `cacheScope`, `-32022` with the supported versions on a mismatch) and the older **2025-11-25**, 2025-06-18, 2025-03-26 and 2024-11-05 through `initialize`. It always speaks UTF-8 over stdio — including Windows consoles in cp1251/cp1252 — and declares all four hints (read-only, destructive, idempotent, open-world) on each of its **9 tools**, and checks every call against the tool&#x27;s schema. Malformed input (`null`, `[]`, a bare number) gets a JSON-RPC `-32600` error instead of crashing the process. Checked end-to-end with the official MCP Python SDK client on 12 Oct 2026.

| Tool | What it does |
|---|---|
| `padam_search` | recall by meaning, words and identifiers; `compact: true` for questions across many conversations; `as_of: &quot;2026-10-01&quot;` for memory as it was on that day (records replaced later are included and marked); `scopes: [...]` to search several scopes at once. Records about who you are that were written around PADAM, and records that contradict another active one, are flagged |
| `padam_write` | store a record; if a close record exists, PADAM decides itself whether it is a duplicate, a refinement or a contradiction. Secrets are masked; some writes wait for the owner (see below). `derived_from: [ids]` links a conclusion to its sources, so forgetting a source can take its conclusions along |
| `padam_confirm` | mark a retrieved record as still true — refreshes it and raises its confidence (retrieval alone never does) |
| `padam_refute` | mark a record as no longer true — lowers its confidence without refreshing it; after enough refutations it is archived but stays in history. Identity and preference records are never archived through this tool |
| `padam_timeline` | version history of a record |
| `padam_stats` | memory state: counts by status and type, records waiting for review, whether consolidation is due, the active embedding backend, where the database lives |
| `padam_sleep` | run a consolidation cycle (normally scheduled, not called by hand) |
| `padam_export` | export the whole memory as JSON, or one page with `limit` and `offset` |
| `padam_profile` | read-only summary of who you are and what you prefer, built strictly from active `identity` and `preference` records with a valid owner signature (fenced as data; unsigned records are skipped) |

For questions that aggregate across many conversations (&quot;how many…&quot;, &quot;how much in total…&quot;), call `padam_search` with `limit` 25–30 and `compact: true`: each record keeps the person&#x27;s words and only the start of the assistant&#x27;s reply, so more of the scattered facts fit in the same space. Stored records are not changed; `compact` is off by default.

**What an agent can and cannot do.** An agent can read a command on a web page and try to carry it out through your memory, so the MCP server treats it as a guest:

- **Search results are fenced as data.** Each answer carries a random marker that stored text cannot know in advance, so a record cannot pretend to end the data block. Records that look like commands are flagged.
- **Secrets never get stored.** API keys and tokens (OpenAI, Anthropic, xAI, GitHub, GitLab, AWS, Google, Stripe, Hugging Face, npm, Neon, Resend, Slack, Vercel, Telegram, JWT, bearer), private keys, passwords in connection strings or said in words (&quot;the password is …&quot;, &quot;пароль — …&quot;), wallet seed phrases (12 or more BIP-39 words), key byte arrays and the private part of a JWK are replaced with `[REDACTED:kind]` before the text reaches the database or the vector. Keys without a known prefix are caught by their shape: a value after a field name such as `client_secret` or `AccountKey`, a long random string, `Basic` credentials, a card number (Luhn plus grouping or the word &quot;card&quot;) with its CVV or PIN. Links, blockchain addresses and signatures, hashes, UUIDs and Vercel ids stay open. Limits: plain hex without a field name looks like a file hash, and base58 of 32–44 characters is treated as an address. Set `PADAM_KEEP_SECRETS=1` to turn this off.
- **Every record says where it came from:** `user`, `agent` or `external`, with starting confidence 1.0, 0.8 and 0.6. An agent repeating its own conclusion does not raise its confidence, so one mistake cannot grow into a &quot;fact&quot; by repetition. Through MCP even `origin: user` does not raise it: the agent sets that label itself.
- **Some writes wait for you.** Held out of search until you decide with `padam review`, `padam approve` or `padam reject`: a write that looks like a command; any identity or preference record from an agent or an external source, also when it is filed under another kind; a write that would replace such a record; and an external source overriding your own record. The first identity or preference record marked `origin: user` is stored, so a fresh memory can learn who you are; every later one waits. Records under review are not shown to agents in search, export or timeline. `PADAM_MCP_TRUST_WRITES=1` turns the review off.

- **`padam_export` is outside the fence.** It returns machine-readable JSON for `padam import` and other tools, so stored text reaches the agent without the data marker. The HOL Guard entry keeps it on review; in other clients keep it behind confirmation or leave it out.
- **There is no erase tool.** Forgetting, approving and restoring exist only in the console and the REST API.

**Recognising commands is a help, not the protection.** The filter knows the usual forms in English, Russian, Ukrainian, Belarusian, Spanish, German, French, Italian, Portuguese, Chinese, Japanese, Korean and Arabic; it looks through look-alike letters, zero-width characters, full-width letters, digits in place of letters, words split letter by letter, and base64, hex, URL and HTML encodings; it knows role-play takeovers (&quot;you are now DAN&quot;), orders to move money to a wallet and orders to send the memory somewhere. A command can still be written in a way no list foresees: on a held-out set written after our fixes, with kinds of attack we had never seen, the filter held 6 of 14 commands. So the protection is structural: memory always comes back to the agent fenced as data, records about who you are cannot be changed by an agent, secrets are not stored, and since 0.4.0 every write the agent marks as `external` waits for your review whatever its wording (`PADAM_HOLD_EXTERNAL=0` turns this off). The agent sets that label itself, so an agent that lies about where a text came from still gets only the dictionary and the fence. MCP gives the server no way to check where an agent got a text; if you need a boundary that does not depend on the label, set `PADAM_MCP_REVIEW_ALL=1` and every agent write waits for you.

### REST API

`python -m padam api` — binds to **127.0.0.1** and refuses to start on a public address without a token (`--token` or `PADAM_API_TOKEN`). Since 0.4.2 it always has a token: given none, it creates one at start and prints it; send it as `Authorization: Bearer `. `--no-token` (local only) connects without one, but then every write waits for your review and owner actions — approve, reject, restore, forget, import, export, the review queue — are refused: whoever reaches the port is not taken for the owner.

Method · Path · Purpose
GET · `/health` · liveness check
GET · `/stats` · memory state
GET · `/export` · whole memory as JSON
POST · `/search` · recall
POST · `/write` · store a record
POST · `/confirm` · `/refute` · confirm or refute a record
POST · `/forget` · revoke a record and destroy its key
POST · `/approve` · `/reject` · `/restore` · decide on a held record · bring an archived one back
GET · `/records?view=active\ · review\ · history&amp;q=…&amp;as_of=…` · records for browsing, newest first
POST · `/sleep` · run NOCTURNE
POST · `/import` · load an export back

**Memory in the browser (`padam studio` and `padam viewer`).** `padam studio` opens the full local application on this computer only (`127.0.0.1`):
- **Overview &amp; Doctor** — active/held/superseded/revoked counts, breakdown by kind, last NOCTURNE sleep run, and a traffic-light security check (`padam doctor`) in plain words;
- **Memory Feed** — day-by-day timeline, filters by kind and text, quick owner write, version history, confirm/refute;
- **Hybrid Search (`--explain`)** — recalls records and shows the exact score formula (`rrf × imp × conf × decay`) and matched strategies;
- **Review Queue** — held agent and external writes with human-readable reasons and **Approve** / **Reject** buttons;
- **Time Machine (`as_of`)** — inspect what your memory knew on any past date, including records replaced later;
- **Forget &amp; Proof of Deletion** — preview versions and derived conclusions (`--with-derived`), double confirmation, and downloadable cryptographic **Forget Receipts** (JSON and printable HTML);
- **Lineage Graph** — zero-dependency interactive `` graph of `derived_from` conclusions, `supersedes` versions, and conflicting facts;
- **Eternal Layer L3** — key protection status, anchored snapshots with Solscan and Arweave links, and one-click `l3-verify`;
- **Settings &amp; Quick Start** — one-switch `PADAM_STRICT`, consolidation profiles, and 1-command onboarding for Claude Code, Cursor, and VS Code (unsafe flags are read-only in the browser).

Try it immediately on a standalone showcase database without touching your real memory:```bash
python -m padam demo --studio

Available in 4 languages (ru, en, es, zh, defaulting to your system language) and 2 themes (dark CODE Eternal and high-contrast light, defaulting to prefers-color-scheme). The printed link carries a one-time token after # (history.replaceState removes it from the address bar immediately); the HTML contains no stored records, renders all content strictly via textContent (0 innerHTML), and enforces Content-Security-Policy: default-src &#x27;none&#x27;; script-src &#x27;nonce-…&#x27;; style-src &#x27;nonce-…&#x27;; connect-src &#x27;self&#x27;; img-src &#x27;none&#x27;. The lightweight single-page padam viewer remains available as well.

Windows Desktop App & System Tray (PADAM-Studio-Setup.exe, see desktop/README.md). Standalone Tauri v2 + NSIS installer (20.97 MB) with the canonical CODE vector logo, Desktop & Start Menu shortcuts, native WebView2 window (remembers size/position), system tray menu (Pending review: N, Open PADAM Studio, Run NOCTURNE Sleep, Quit), native Windows Toast notifications when a suspicious agent write is held for review, optional autostart checkbox in Settings (off by default), and bundled Python 3.14.4 (runtime/python.exe) in an open directory (no --onefile self-extracting dropper). SmartScreen note: the installer is not yet signed with a paid Authenticode certificate — on first run click More info → Run anyway.

POST bodies must be application/json objects of at most 10 MB. When running locally the server accepts only local Host and Origin headers, so a web page you happen to open cannot read your /export through DNS rebinding.

CLI

Command · Purpose
remember · recall · store a memory · recall by meaning, words and identifiers (--explain shows why)
log · sleep · add to the episode buffer · run the consolidation cycle
confirm · refute · a record is still true · no longer true
timeline · version history of a record
forget · revoke a record with its versions, exact copies and source episodes, and destroy their keys; --with-derived also wipes the conclusions drawn from it (they are listed first)
viewer · memory in the browser: timeline, forget, review, memory as of a date
alias add\ · remove\ · list · term aliases: rename a project and search by the new name finds the old records
trust-protected · list identity and preference records not signed by you (written around PADAM); --yes signs them
legacy split\ · combine · split the key passphrase into Shamir shares (any k of n open it, fewer reveal nothing) · put it back together
panic · emergency forgetting: destroy every record key (what reached Arweave becomes noise); --wipe-local also wipes the local memory. Asks you to type the phrase in full
review · approve · reject · writes held for the owner: list, accept, reject
restore · bring an archived record back
reindex · recompute vectors after changing the embedding model
stats · memory state, including whether record keys are protected
doctor · the security state in one report: switches that weaken protection, record keys, file integrity (PRAGMA quick_check), file modes, the REST token; exit code 1 on a warning
backup · a consistent copy through SQLite's backup API, owner key beside it; never overwrites; forgetting cannot reach a copy
export · import · the whole memory as JSON and back
serve · api · start the MCP server (stdio) · start the REST API
l3 · l3-verify · anchor to Arweave + Solana · verify an anchoring independently
protect-keys · rekey · protect per-record keys with a passphrase · change it

Cloud version — no install (AIfa Memory MCP)

Don't want to run anything locally? The same memory runs as a hosted MCP server, version 1.9 (fifteen tools): POST https://aifa.works/api/mcp (Streamable HTTP, JSON-RPC 2.0, one bearer key per account). Key and full guide: .

Tool What it does
memory_search · memory_recent recall by meaning · the latest records across all channels
memory_write · memory_about save a fact or decision (marked as written by an agent) · how the memory is protected
account_status · plans plan, permanent memory this month, referral network and earnings · prices and earning rules
buy_plan a crypto invoice (USDT and other coins via NOWPayments) for the agent's own account
request_payout withdraw earnings in USDT to a TRC20 address pinned to the account; OFAC sanctions check; one-time tax self-certification of the operator
memory_export the whole memory of the account as Markdown
partner_kit · client_link · client_report · find_clients · my_deals · set_webhook partner program for services: rates, rules and email templates in 4 languages · a client link with your partner code · your paid deals and when they unlock

For autonomous agents (new, in testing). An agent with its own mailbox gets a key over plain HTTPS (/api/auth/send-code → code from the mailbox → /api/auth/verify-code → /api/account/mcp-token), pays for its own memory, and gets a referral reward of 15% / 7% / 3% in USDT from every real plan payment by the people it brings, over three levels, whatever its own plan — a Free account included (the tier condition was removed on 6 Nov 2026). An agent has no legal personhood: payouts go to whoever operates it, under the terms of CODE Eternal LLC (New Mexico). Partner program for services: an agent that brings a client to AIfa Works accessibility services earns 30% on audits, fix-pack and monitoring (renewals for 12 months) and 20% on remediation and websites — one level, any account including Free, available 14 days after payment. Terms: . Details may be refined while the feature is tested.


Record kinds and how they fade

Kind Half-life Typical content
preference never fades "answer in Russian, no filler"
identity never fades who the user is
decision 365 days "we chose Postgres for billing"
correction 365 days "no, the deadline is the 14th"
fact 180 days a stable fact about the world or the project
state 14 days "the release is in testing"
event 2 days "today we debugged the billing"

Omit --kind and PADAM guesses it (rules, or a small local model through Ollama — PADAM_CLASSIFY_MODEL, default llama3.2:1b). Decay is counted from the last confirmation, not the last retrieval.

Search

Works out of the box with no model: words + BM25 + identifiers (names, numbers, ids are matched exactly). For search by meaning there are two local ways:

  • In the same process, no service to run (since 0.4.0): pip install &quot;padam-nocturne[embed]&quot;, or for MCP claude mcp add padam -- uvx --from &quot;padam-nocturne[embed]&quot; padam-nocturne. This adds model2vec with a static embedding model of about 30 MB (minishlab/potion-base-8M, MIT licence), downloaded from Hugging Face on first use. After that it loads from the local cache without touching the network: checked with a counter on every connection, 0 connections on a filled cache, and by a test that closes the network. On the CPU it embeds a text in 0.41 ms against 0.31 ms for the built-in method (1,000 LongMemEval turns of 936 characters on average, 9 Nov 2026).
  • Ollama: install Ollama and ollama pull nomic-embed-text. Long records are embedded through /api/embed with truncation to the model window (PADAM_EMBED_CTX, default 8192), so a record longer than the window still gets a real vector instead of silently falling back to an incompatible one.

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

常见问题

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

在客户端按下面的安装命令接入:claude mcp add padam -- uvx padam-nocturne。装完在客户端配置里引用同一个包或端点。

PADAM NOCTURNE 怎么在 Claude Desktop、Claude、Cursor 里配置?

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

PADAM NOCTURNE 收费吗?

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

PADAM NOCTURNE 需要 API Key 吗?

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

PADAM NOCTURNE 支持哪些客户端?

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

PADAM NOCTURNE 能提供哪些能力?

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

PADAM NOCTURNE 需要什么运行环境?

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

PADAM NOCTURNE 是本地还是远程?

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

热门专题

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

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