# Pastepile (npm · @pastepile/mcp)

Durable, versioned memory for AI assistants. Remote memory needs a Pastepile subscription.

- Trust score: 65/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-07

## Components

- remote · `www.pastepile.com`: 66/100, [markdown](https://verifymcp.io/servers/com-pastepile-mcp/api-mcp.md), [page](https://verifymcp.io/servers/com-pastepile-mcp/api-mcp)
- npm · `@pastepile/mcp`: 65/100 (this document), [markdown](https://verifymcp.io/servers/com-pastepile-mcp/pastepile-mcp.md), [page](https://verifymcp.io/servers/com-pastepile-mcp/pastepile-mcp)

## Channel facts

- Registry: `npm`
- Package: `@pastepile/mcp`
- Version: `0.9.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-07.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 19/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 74/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3609 tokens (~300/item across 12 items; 11 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 10/100
  - Stability observed for 3 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).
  - Supports UI / widget rendering.

## Install

### Claude

```bash
claude mcp add com-pastepile-mcp -- npx -y @pastepile/mcp
```

### Codex

```bash
codex mcp add com-pastepile-mcp -- npx -y @pastepile/mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-pastepile-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@pastepile/mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-pastepile-mcp --command npx --arg -y --arg @pastepile/mcp
```

### Hermes

```yaml
mcp_servers:
  com-pastepile-mcp:
    command: "npx"
    args: ["-y", "@pastepile/mcp"]
```

### Other

```json
{
  "mcpServers": {
    "com-pastepile-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@pastepile/mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-07 (score 65, +31)

- [functional regression] Schema quality: 2785 → 3609
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Stability: unverified → 0.10
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Capabilities: pass
- [functional] Package version: 0.7.0 → 0.9.0

### 2026-08-06 (score 34, −25)

- [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Capabilities: fail → unverified
- [functional] Package version: 0.5.0 → 0.7.0
- [functional] Package version: 0.5.0 → 0.6.0

### 2026-08-05 (score 59, +40)

- [security improvement] Malware scan: unverified → pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional regression] MCP protocol: unverified → fail
- [functional improvement] Tool coverage: unverified → 100
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: excellent
- [functional] First check of Tool coverage: 100

### 2026-08-04 (score 19)

First indexed and scored.

## MCP tools (11)

### `pastepile_remember` (~598 tokens)

Save the current state of your work to durable memory, keyed by a session name YOU choose. This is the primary tool: prefer it over pastepile_save for anything you may want back later. The first call under a session creates the memory; every call after updates that same memory and keeps the previous content as a version; a call whose content is unchanged does nothing and costs nothing. You never need to track a slug, a URL, or an edit key between calls, and you must never ask the user for one. Send the WHOLE current memory each time, not a delta. Works without an API key as trial memory (expires a month after its last save, searchable from this device only); a Pro API key makes memory permanent and portable.

Input parameters:

- `content` (string, required): The complete memory as it stands now. It replaces the current content; the previous copy is preserved in version history.
- `encrypted` (boolean): Seal the content on this machine before sending it, so Pastepile stores ciphertext it cannot open. The key is generated once and kept in a file on this device; IF THAT FILE IS LOST THE MEMORY IS UNRE…
- `kind` (string): What this memory IS, so recall can filter by it. Defaults to "conversation".
- `language` (string): Syntax-highlighting language. Defaults to "markdown", which is usually right for conversation memory.
- `pile` (string): Optional named collection to file this memory into, created on first use, e.g. "architecture-decisions". Lets a set of related memories be opened and shared with one link.
- `session` (string, required): A stable name for this thread of work that you can reproduce from what you can see right now, for example "acme-api/auth-refactor" or a repository path plus the task. Reuse it for every save about th…
- `tags` (array): Up to 20 short labels for later retrieval, e.g. ["auth", "postgres"]. Lowercase letters, digits and single hyphens; other spellings are rejected rather than silently dropped.
- `title` (string): A short, stable title. Keep it the same across saves of the same memory so the history reads as one thing changing. Defaults to the session name.

### `pastepile_recall` (~195 tokens)

Search YOUR OWN memory (everything saved with the configured API key) by text, tag, and kind, newest and most relevant first. Use this at the start of a session when the user refers to earlier work, and before asking them to repeat context you may already be holding. Returns titles, previews, sessions and URLs, not full bodies; fetch one with pastepile_get when you need all of it. With an API key this searches that key's memory from any machine; without one it searches the trial memory this device saved.

Input parameters:

- `kind` (string): Only memories of this kind.
- `limit` (integer): Maximum results to return (1-100, default 20).
- `query` (string): Words to match against titles and contents. Quoted phrases and -exclusions work. Omit to list recent memory instead of searching.
- `tags` (array): Only memories carrying ALL of these tags.

### `pastepile_timeline` (~204 tokens)

Show one memory's full version history plus the memories most related to it. Each entry has a version number, a timestamp, a size and a preview, so you can see how the work changed without downloading every revision. Pass a version number to pastepile_restore to bring one back. Name the memory by `session` if you still know the session name you saved under, which you usually do, or by `slug` if you have it. Give exactly one. With an API key this reads that key's full server-side history; without one it reads this device's trial-memory timeline.

Input parameters:

- `session` (string): The session name you passed to pastepile_remember. Prefer this: it is the identifier you can reproduce after a long conversation, and the slug is not.
- `slug` (string): The memory slug (e.g. "abc123") or its full Pastepile URL, as returned by pastepile_remember or pastepile_recall.

### `pastepile_restore` (~183 tokens)

Put an earlier version of a memory back as the current one. This is not destructive: what is current now is preserved as a new version first, so a restore can itself be undone. Use it when a memory was overwritten with something worse, or to return to a known-good state after an experiment. Name the memory by `session` or by `slug`, exactly one. With the API key that wrote the memory, any listed version can come back; trial memory (no key) restores the previous save only.

Input parameters:

- `session` (string): The session name you passed to pastepile_remember. Prefer this: an undo is most often wanted long after the slug scrolled away.
- `slug` (string): The memory slug or its full Pastepile URL.
- `version` (integer, required): The version number to restore, as listed by pastepile_timeline.

### `pastepile_save` (~371 tokens)

Save text, code, notes, or any knowledge to Pastepile and get back a stable, shareable URL you can retrieve later. Use this as durable memory: whenever you produce output worth keeping across sessions, save it and remember the returned slug or URL. Returns url, slug, raw_url, and edit_key. The edit_key is shown only once and is required to update with a per-paste credential. With an API key configured, pastepile_checkpoint updates a paste that same key saved using only its slug, while preserving the previous revision in history. Deleting is separate: pastepile_forget removes a paste saved with the configured API key using only its slug.

Input parameters:

- `content` (string, required): The text or code to store. Required.
- `expiry` (string): When the paste expires. Defaults to "never" so stored knowledge persists. "burn" destroys it after the first read.
- `language` (string): Optional syntax-highlighting language, e.g. "typescript", "python", "markdown". Defaults to "plaintext".
- `pile` (string): Optional memory namespace, e.g. "architecture-decisions" or "debugging-notes". Saves this paste into a named Pile that is created on first use and appended to every time after, so related context sta…
- `title` (string): Optional short title for the paste.
- `visibility` (string): "unlisted" (default) keeps the paste out of public listings and search but retrievable by URL. "public" also lists it and makes it findable via pastepile_search.

### `pastepile_checkpoint` (~263 tokens)

Update an existing Pastepile memory while preserving its previous content in version history. Use this for conversation snapshots: after significant growth, a debugging breakthrough, an architecture decision, a large code generation, or before context compaction. With an API key configured, it can checkpoint any paste that same key created without the one-time edit_key. Otherwise pass the edit_key returned by pastepile_save. Reusing one slug avoids duplicate memories while keeping every prior checkpoint recoverable from the paste's version history.

Input parameters:

- `content` (string, required): The complete current memory to store. Required. The previous content becomes a version-history checkpoint.
- `edit_key` (string): Optional. The one-time edit key returned by pastepile_save. Only needed when the configured API key did not create this paste. When both credentials are available, the narrower edit key is used.
- `language` (string): Optional syntax-highlighting language, e.g. "markdown", "typescript", or "python". Defaults to "markdown" for conversation memory.
- `slug` (string, required): The paste slug (e.g. "abc123") or full Pastepile URL to checkpoint. Required.
- `title` (string, required): A short, stable title for this memory. Required so search keeps a strong signal across checkpoints.

### `pastepile_get` (~220 tokens)

Retrieve a previously saved paste or memory in full, by slug, full Pastepile URL, or the `session` a memory was saved under. Returns the title, language, and file contents. Use this after pastepile_recall when a preview is not enough. An ENCRYPTED MEMORY of your own is decrypted here on this machine with the key in your Pastepile state directory; if that key is missing or wrong this says so rather than returning ciphertext. Password-protected and burn-after-read pastes, and encrypted pastes belonging to someone else, are not retrievable through this tool.

Input parameters:

- `session` (string): The session name a memory was saved under with pastepile_remember. Use this when you no longer have the slug, which is the usual case after a long conversation. Give this or `slug`, not both.
- `slug` (string): The paste slug (e.g. "abc123") or a full share URL (e.g. "https://pastepile.com/p/abc123"). Give this or `session`.

### `pastepile_search` (~162 tokens)

Search Pastepile pastes by keyword and get back matching titles, previews, and URLs. With an API key configured this defaults to scope "mine": YOUR private memory, the pastes saved with that key (titles, filenames, and contents, including unlisted pastes). Use scope "public" to search the global public corpus instead. Without a key only the public scope is available.

Input parameters:

- `limit` (integer): Maximum results to return (1-100, default 20).
- `query` (string, required): Keywords to match against paste titles and content. Required.
- `scope` (string): "mine" searches pastes saved with the configured API key (default when a key is set); "public" searches the public corpus (default without a key).

### `pastepile_list` (~119 tokens)

List recent Pastepile pastes. With an API key configured this defaults to scope "mine": YOUR saved pastes, newest first, including unlisted ones. Use scope "public" for the public feed. For targeted lookups use pastepile_search instead.

Input parameters:

- `limit` (integer): Maximum results to return (1-100, default 20).
- `scope` (string): "mine" lists pastes saved with the configured API key (default when a key is set); "public" lists the public feed (default without a key).

### `pastepile_memory_key` (~282 tokens)

Back up, check, and restore the key that opens your encrypted memories. Pastepile does not have this key and cannot reissue it, so a machine that loses it loses those memories permanently. Use `status` to see whether a key exists here, `backup` to write a copy to a path the user gives you, `verify` to confirm a backup file still matches, and `restore` to install a key on a new machine. NONE of these ever returns the key itself: it would land in this conversation and in whatever logs the conversation reaches. Tell the user the file path and let them move the file.

Input parameters:

- `action` (string, required): status: is there a key on this machine. backup: copy it to `path`. verify: does the key in `path` match the one here. restore: install the key from `path`.
- `path` (string): The file to write to or read from. Required for backup, verify and restore. Ask the user where; do not invent a location, and do not choose somewhere that syncs to a service they did not name.
- `replace` (boolean): Only for restore, and only after the user has said yes. Replacing a different key that is already installed makes whatever it sealed unreadable, permanently and silently. Without this, restore refuse…

### `pastepile_forget` (~295 tokens)

Permanently delete a paste from Pastepile. Use this when the user asks you to forget, remove, or delete something you saved earlier. With an API key configured you can delete any paste that was saved with that key, WITHOUT the one-time edit_key, which is what makes saved memory reversible across sessions. A paste saved with no key (or by someone else) needs its edit_key passed explicitly. Deletion is immediate and permanent: there is no undo and no trash. Confirm with the user before forgetting anything they did not just ask you to forget.

Input parameters:

- `edit_key` (string): Optional. The one-time edit key from the pastepile_save result. Only needed for a paste that the configured API key did not create, for example one saved with no key at all. When both credentials are…
- `session` (string): Alternative to `slug`: the session name a memory was saved under with pastepile_remember. Use this when the user asks to forget a memory by what it is about and the slug is no longer in the conversat…
- `slug` (string): The paste slug (e.g. "abc123") or a full share URL (e.g. "https://pastepile.com/p/abc123"). Required.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-pastepile-mcp/pastepile-mcp#diagnostics

## Score history

- 2026-08-07: 65
- 2026-08-06: 34
- 2026-08-05: 59
- 2026-08-04: 19

## Links

- npm package: https://www.npmjs.com/package/@pastepile/mcp
- Socket report: https://socket.dev/npm/package/@pastepile/mcp
- Website: https://www.pastepile.com/mcp
- Changelog RSS feed: https://verifymcp.io/servers/com-pastepile-mcp/pastepile-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-pastepile-mcp/pastepile-mcp.json
- HTML version of this page: https://verifymcp.io/servers/com-pastepile-mcp/pastepile-mcp