Skip to main content
plugin CX Codex

memory · dodo-labs-ai, claude-code — Claude Code plugin: what it does, how to install

memory is a Claude Code plugin that links the agent to the MemForge API via a local MCP proxy. It adds session guidance and on-demand memory lookup tools.

Apache-2.0 ★ 104 updated 2026-11-17

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add dodo-labs-ai/mem-forge
/plugin install memory@memforge
Open on GitHub

What memory does

The plugin connects Claude Code to a MemForge instance through a bundled MCP proxy. Its SessionStart hook inserts usage guidance when a session opens, resumes, or compacts, while tools like search, get_memory, and list_recent_memories handle queries during execution. The plugin does not capture conversations automatically; writing a private memory requires an explicit request and user confirmation of the preview.

Requests default to a local server at http://127.0.0.1:8765/api/v1. Pointing to another host requires setting MEMFORGE_API_URL and MEMFORGE_API_TOKEN in ~/.claude/settings.json. Registering a manual MCP server block in configuration breaks updates because it binds the agent to an obsolete plugin cache path.

What it helps with

  • search MemForge records for project context
  • fetch artifact files into ~/.memforge-agent/artifacts via get_resource
  • write confirmed memory entries using create_memory
  • retrieve recent memories across a specified timestamp window

Example prompts for the agent

  • Use MemForge to search for "deployment credentials".
  • Find the memory about database migrations and get the attached file using get_resource.
  • Save this architectural decision to MemForge.

How to install memory

Plugin marketplace

/plugin marketplace add dodo-labs-ai/mem-forge
/plugin install memory@memforge

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about memory

How to install memory in Claude Code?

Run /plugin marketplace add dodo-labs-ai/mem-forge followed by /plugin install memory@memforge inside Claude Code. Start a new session once installation finishes.

What does memory do?

It supplies MCP tools to query, inspect, and write MemForge entries without auto-logging entire sessions.

What is required to run memory?

A running MemForge API endpoint is required, either locally at http://127.0.0.1:8765/api/v1 or configured via MEMFORGE_API_URL and MEMFORGE_API_TOKEN in ~/.claude/settings.json.

Source text

memforge-memory · Apache-2.0
# MemForge Memory for Claude Code

This plugin connects Claude Code to a MemForge API through a thin local MCP proxy
for memory tools, and adds MemForge usage guidance when a session starts.
The packaged runtime and plugin version is `0.2.0-beta.4`.

With no routing variables, the plugin targets local OSS at
`http://127.0.0.1:8765/api/v1`. Otherwise put the target in the top-level `env`
object in `~/.claude/settings.json`. `MEMFORGE_API_URL` must be an HTTP(S)
origin without an API path. OSS and Cloud share the same `/api/v1` contract.

```json
{
  "env": {
    "MEMFORGE_API_URL": "https://memforge.example.com"
  }
}
```

Set `MEMFORGE_API_TOKEN` separately in the process or
top-level agent environment when bearer authentication is required; the token
is an identity credential, not a workspace selector. Call `list_workspaces`
when discovery is useful and pass optional `workspace_id` to any data tool for
a one-request override. It may be omitted when the account has exactly one
accessible workspace or the project has a user-confirmed local binding. Use the
`memforge-setup` skill to bind a Git repository or ordinary directory. Use
`memforge-daemon-setup` when the agent should securely install, configure,
verify, troubleshoot, or remove the managed local collection daemon.
Repository context remains
provenance attribution; it never selects or authorizes a workspace.

Do not add a manual MCP server block for MemForge. The plugin's `.mcp.json`
registers the MCP server; duplicating it in config can pin the agent to a stale
plugin cache path after upgrades.

The bundled MCP proxy does not need a local MemForge CLI or local-DB MCP
process. It forwards search, current recent-Memory listing, memory detail, memory write, and Review
calls through the configured immutable target. `get_resource(mode="file")` is handled
locally so returned `local_path` values point to the agent machine.

```text
Claude Code MCP stdio -> plugin-local proxy -> HTTP(S) MemForge API
get_resource(mode=file) -> ~/.memforge-agent/artifacts -> local_path
```

Claude Code may pass its exact current working directory through the optional
MCP `repository_context` argument on every MemForge tool. The local proxy uses
it to derive a normalized Git remote, then
discards the path before calling OSS or Cloud. Negotiated request-scoped host
context, when supported by a client, sits behind an explicit argument and ahead
of compatible MCP Roots. Malformed
negotiated or explicit context fails before HTTP instead of silently reading
another workspace.

Install from GitHub (run inside an active Claude Code session):

```text
/plugin marketplace add dodo-labs-ai/mem-forge
/plugin install memory@memforge
```

Start a new Claude Code session after install.

To push a local folder as a source, open the MemForge Admin UI, choose
**Add Source -> Local Repository**, and run the printed CLI command.

Try a search:

```text
Use MemForge to search for "<topic>". If source evidence matters, call
get_memory on the relevant result before citing source details.
```

List current Memories observed from active sources during a resolved time
window without inventing a topic query:

```text
Use MemForge list_recent_memories for 2026-07-21T00:00:00+08:00 through
2026-07-28T00:00:00+08:00. This is a current-Memory view, not a source
changelog. Follow next_cursor with the same filters until has_more is false.
```

Fetch backing evidence:

```text
Search MemForge for "<topic>". Call get_memory for the relevant memory, then
call get_resource with mode="file" on the best content_url or pdf_url and show
the local_path.
```

The plugin registers one hook, `SessionStart`. It adds static MemForge usage
guidance to a new, resumed or compacted session, and it makes no network call
and writes no local state. Per-prompt memory retrieval is left to the MCP
`search` tool, which fetches query-aware context on demand.

The bundled MCP proxy exposes tools such as `search`, `list_recent_memories`,
`get_memory`, and `get_resource`.
`get_resource` fetches `content_url` / `pdf_url` artifacts through
`MEMFORGE_API_URL`; in `file` mode it writes the artifact to
`~/.memforge-agent/artifacts`.

The plugin captures nothing on its own. To keep something, ask Claude Code to
remember it: the agent shows a preview, and after you confirm it writes one
private Memory with the MCP `create_memory` tool.

## Upgrading from 0.2.0-beta.1 or earlier

Earlier plugin releases uploaded redacted session windows automatically. That
capture is removed, and MemForge refuses those uploads. Update the plugin and
restart Claude Code:

```bash
claude plugin marketplace update memforge
claude plugin update memory@memforge
```

After the update:

- You can delete `queue.sqlite`, `queue.sqlite-wal`, `queue.sqlite-shm` and
  `worker.lock` in `~/.memforge-agent`; nothing reads them. Keep `~/.memforge-agent/artifacts` if you use
  `get_resource(mode="file")`.
- A `hook_workspace_id` entry in `~/.memforge/workspace-bindings.json` is
  ignored. The `memforge-setup` skill reports it and can remove it.
- Memories captured from earlier sessions belong to the Claude Code Session
  Source. A MemForge server on a release after 0.2.0b2 retires that Source
  when it upgrades, with the Memories no other Source supports. On a server
  still on 0.2.0b2, delete the Source in the admin UI to retire it the same way.

## Troubleshooting

**Claude Code shows `MemForge hook skipped: /hooks/receipts returned HTTP 410` or
`MemForge hook skipped: /hooks/receipts returned HTTP 404` at the end of a turn
or at compaction.** An earlier plugin release is still installed, and MemForge
no longer accepts its session uploads: a 0.2.0b2 server answers `410`, and a
later server, which no longer has the upload routes, answers `404`. Update the
plugin with the commands above and restart Claude Code.

© MemForge Team · Apache-2.0 · dodo-labs-ai/mem-forge

Similar plugins

All plugins for Agent setup: memory, context, orchestration →

memory by other authors comes first.

memory MemForge Team memory is a Claude Code plugin that connects to MemForge search and memory tools. Session-start guidance appears automatically; retrieval runs on request. CX Codex ★ 104repo stars para-memory-files paperclipai para-memory-files — a skill for storing knowledge and facts across IA coder sessions. Organizes memory by the PARA method: projects, areas, resources, and archives in separate files, with vector and keyword search. CX Codex +1 1,900installs memory-reflect basicmachines-co memory-reflect is a Claude Code skill that reviews recent project logs and merges durable decisions into persistent notes. It runs on a scheduled heartbeat or on request. CX Codex +1 1,500installs memory-capture basicmachines-co memory-capture turns the current outcome of a conversation into a Basic Memory note and revises that note when run again. Use it when a thread has produced decisions or context worth keeping. CX Codex +1 1,500installs memory-management aaron-he-zhu memory-management is a Claude Code skill for project working memory. It saves, retrieves, merges, and archives notes when an agent handles cross-session context or an erasure request. CX Codex +1 1,200installs memory-intake nhadaututtheky memory-intake turns messy notes and conversations into typed memories with tags, priority and expiry. Useful when raw input needs to be filed instead of dumped. CX Codex +1 780installs video-memory oxbshw video-memory is a Claude Code skill that searches videos watched in earlier sessions. Ask about a past clip, a meeting decision, or a topic covered across several recordings. CX Codex +1 748installs

From the same set8

memory memory is a Claude Code hook that loads MemForge guidance and MCP memory tools at session start. It triggers automatically whenever a session starts, resumes, or compacts. CX Codex ★ 104repo stars memory memory is a Claude Code plugin that connects to MemForge search and memory tools. Session-start guidance appears automatically; retrieval runs on request. CX Codex ★ 104repo stars lifecycle-canary-convergence lifecycle-canary-convergence is a Claude Code skill that checks Memory lifecycle state through an inventory, dry-run, apply, and audit. It runs before another retry or canary. CX Codex +1 ★ 104repo stars self-hosted-release-validation self-hosted-release-validation is a Claude Code skill that validates OSS self-hosted releases via Docker Compose. Evaluates SQLite persistence, agent sources, and beta readiness. CX Codex +1 ★ 104repo stars memforge-setup memforge-setup is a Claude Code skill for configuring MemForge workspace routing. It runs on requests to bind or remove a project binding, or to diagnose workspace selection. CX Codex +1 ★ 104repo stars plugin-release-validation plugin-release-validation is a Claude Code skill that validates MemForge memory plugin releases via remote marketplace paths. Runs when testing RC tags, checking caches, hooks, and MCP servers. CX Codex +1 ★ 104repo stars memforge-daemon-setup memforge-daemon-setup is a Claude Code skill that installs and configures the MemForge local daemon as a macOS or Linux user service. It runs for requests to connect, inspect, repair, or remove that service. CX Codex +1 ★ 104repo stars

Project sponsors

Companies that keep this analytics open