Local MCP memory for coding agents, with governed records, retrieval, coordination signals, and recoverable run histories.
Copy the AI prompt to install this server into Claude Code, Cursor, or another agent โ or use 1-click editor setup below.
We haven't yet run this listing's install command through our automated sandbox check. This isn't a red flag โ we're steadily working through the catalog.
๐ก Paste the JSON block into your client's configuration file under mcpServers, then restart the application.
Inspect callable tools, capabilities, and parameters exposed to AI agents by Agent Memory Bridge.
storeCallable MCP tool function
recallCallable MCP tool function
browseCallable MCP tool function
statsCallable MCP tool function
forgetCallable MCP tool function
feedbackCallable MCP tool function
Carry project decisions into the next coding session.
AMB helps coding agents remember the decisions that matter โ across sessions, tools, and time.
Install once; connect each coding client separately. Installing the package does not register AMB with every coding agent. Each client you want to use must be configured to launch AMB as an MCP stdio server. Clients that should share memory need to use the same configured local AMB home.
A project is more than its current files. Over time, useful context gets scattered across repositories, chats, coding agents, reviews, fixes, and one-off decisions. A new session can see the code but still miss the reasons that make the project make sense.
AMB gives those decisions a durable place to live. The first win is simple: teach one real decision, close the session, open a fresh coding-agent session, and hear the same decision come back from AMB.
| Without shared project memory | With AMB |
|---|---|
| Each session reconstructs context | Useful project knowledge carries forward |
| Decisions disappear into old chats | Explicit decisions and reasons stay with the project |
| Different tools build different partial pictures | Supported MCP clients can use the same configured local AMB home |
| Memory can become stale or ambiguous | Provenance, revision, supersession, and inspection keep it governable |
AMB is local-first and inspectable. It does not silently archive every conversation or treat every remembered statement as equal authority.
AMB requires Python 3.11+, Git, and an MCP-compatible coding client that can launch a local stdio server.
Current package/source version: 0.33.0.
Published releases: see GitHub Releases.
The first win happens inside the coding agent, in a fresh session. CLI Explore/Inspect and doctor/verify are later checks, not that win.
For the Quick Start, use a virtual environment so every coding client can point at one stable Python launcher. Replace <venv-python> with the Python executable inside .amb-venv for your operating system.
For development or audit work against an exact source checkout, use:
Installation and client registration are separate. Preview the setup for one client first:
setup is read-only by default: it detects or inspects only bounded client configuration locations and shows the exact AMB fragment or action it recommends. Use a supported client name such as codex, claude-code, vscode, cursor, cline, opencode, or another client listed in Integrations. Codex is the reference workflow.
If the preview marks that client as eligible for safe automatic configuration, you can explicitly apply it after review:
Some clients remain preview/manual because AMB will not guess or rewrite an unsafe configuration format or path. In that case, copy the rendered fragment or follow the client-specific Integration guide. Repeat this step for every coding client you want to connect. To share the same project memory across clients, keep them pointed at the same configured AGENT_MEMORY_BRIDGE_HOME, then reload each client after registration.
Connection is proven when the coding client itself lists AMB tools such as store and recall. doctor and verify do not prove that an external client loaded MCP config.
Project Init detects the local Git repository, proposes a namespace such as project:my-app, and waits for confirmation. It then derives a current repository baseline. It does not automatically learn decisions.
In the connected coding agent, teach a decision you actually made. For example:
Remember that we merge pull requests only after CI is green on the target branch, because broken main blocked two releases this month.
The connected agent uses AMB's public store tool to persist the explicit decision and reason. AMB does not infer a durable decision from the code or archive the whole conversation.
Another valid example is a stack choice, such as staying local-first instead of adding Redis. The win is the decision plus reason, not any one technology.
End the first agent session completely. Open a new session against the same project, same client registration, and same AMB home. Ask a generic question:
What is required before we merge a pull request?
The first win is when the new session answers with the stored decision and reason because AMB recalled it. Seeing the same fact in CLI Explore or Inspect is useful review, not the success check.
Exact Codex observation steps live in First-win acceptance.
Once one decision survives a fresh session, you can inspect what AMB knows, keep repository facts current, and use the governance model below.
Human-first Explore answers โWhat does AMB currently know about this project?โ Inspect answers โWhy did this information surface for this question?โ Both are local and read-only.
This is a conceptual view, not verbatim CLI output:
Code tells AMB WHAT the project is.
Conversations teach AMB WHY it is that way.
That distinction is a trust boundary: derived facts can be rebuilt from current code, while durable project knowledge remains explicit, reviewable, and governed.
Repository WHAT comes from a clean Git commit. If HEAD changes or the worktree is dirty, AMB will not present an old snapshot as current truth. Refresh is not automatic. Rerun the explicit primitive:
Refreshing repository WHAT leaves durable project WHY unchanged. Explore is CLI-only, not MCP tool #18, and it does not rank context for the model.
first-run remains optional guided help; it is not the first-win path:
Use health checks only when setup is uncertain. They do not prove that a coding client loaded MCP config:
AMB works through local stdio MCP. Generic MCP clients are supported; Codex is the reference workflow; Claude Code, Claude Desktop, Cursor, and Cline are documented; and Antigravity, OpenCode, and Hermes have locally tested configuration paths.
Integration labels are deliberately narrow and do not imply client certification. See Integrations for current setup instructions and boundaries.
The useful part of long-lived project memory is not simply remembering more. It is being able to tell where knowledge came from, whether it is still current, and how it changed.
AMB therefore keeps several boundaries explicit:
| Memory concern | AMB approach |
|---|---|
| Current repository truth | Derived from a clean repository state and refreshed explicitly |
| Human decisions and constraints | Stored explicitly as governed durable memory |
| Changed knowledge | Revised or superseded instead of silently overwritten |
| Why context surfaced | Inspectable through local derived views and evidence paths |
| Cross-session reuse | Shared through the same configured local AMB home |
| Privacy | Local-first; no hosted memory service is required |
Factual signals from GitHub, npm, and our automated checks โ not a rating.
No reviews yet โ be the first to share how this listing worked for you.
Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.
[](https://allmcps.com/mcp/zzhang82-agent-memory-bridge)<a href="https://allmcps.com/mcp/zzhang82-agent-memory-bridge"><img src="https://allmcps.com/api/badge/zzhang82-agent-memory-bridge?style=directory" alt="Agent Memory Bridge on AllMCPs" /></a>