# How to Integrate agentmemory with Claude Code's MEMORY.md Bidirectional Bridge

> Seamlessly integrate agentmemory with Claude Code's MEMORY.md using the memory_claude_bridge_sync MCP tool. Achieve bidirectional sync for effortless knowledge transfer.

- Repository: [Rohit Ghumare/agentmemory](https://github.com/rohitg00/agentmemory)
- Tags: how-to-guide
- Published: 2026-05-10

---

**The `memory_claude_bridge_sync` MCP tool enables bidirectional synchronization between Claude Code's MEMORY.md file and agentmemory's persistent store, handling JSONL conversion for seamless knowledge transfer in both directions.**

The `rohitg00/agentmemory` repository ships with a dedicated bridge that allows you to integrate agentmemory with Claude Code's MEMORY.md bidirectional bridge using the Model Context Protocol (MCP). This integration treats Claude's memory file as a JSONL transcript that can be imported into agentmemory's vector database or exported back to update Claude's local context.

## How the Bidirectional Bridge Works

The bridge operates through two distinct data flows defined in the MCP tool registry. According to the `rohitg00/agentmemory` source code, the tool `memory_claude_bridge_sync` is declared in [[`src/mcp/tools-registry.ts`](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/tools-registry.ts)](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/tools-registry.ts) with a JSON schema that accepts a `direction` parameter (`"import"` or `"export"`) and an optional `filePath`.

When invoked, the handler in [[`src/mcp/server.ts`](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/server.ts)](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/server.ts) routes requests to the appropriate pipeline:

- **Import (Claude → agentmemory)**: Parses the [`MEMORY.md`](https://github.com/rohitg00/agentmemory/blob/main/MEMORY.md) file into JSONL observations and stores them via the `mem::remember` function.
- **Export (agentmemory → Claude)**: Calls `mem::exportAll` from [[`src/functions/export-import.ts`](https://github.com/rohitg00/agentmemory/blob/main/src/functions/export-import.ts)](https://github.com/rohitg00/agentmemory/blob/main/src/functions/export-import.ts) to stream the entire memory graph as a JSONL payload.

## Installation and MCP Server Setup

To enable the bridge, you must install the MCP server and register the tool with Claude Code.

1. **Install the MCP server globally.**

   ```bash
   npm i -g @agentmemory/mcp
   npx @agentmemory/mcp
   ```

2. **Register the tool in your Claude Code plugin.**

   Edit your project-specific plugin configuration at `~/.claude/projects/your-project/.claude-plugin/plugin.json` and add `"memory_claude_bridge_sync"` to the tools array:

   ```json
   {
     "tools": [
       "memory_claude_bridge_sync"
     ]
   }
   ```

   Alternatively, set the environment variable `AGENTMEMORY_TOOLS=all` to expose every core tool without explicit listing.

## Configuring Bridge Behavior

Fine-tune the synchronization behavior using environment variables before starting the MCP server:

- **`AGENTMEMORY_ALLOW_AGENT_SDK=true`**: Enables a Claude SDK fallback for handling large imports that exceed standard MCP payload limits.
- **`AGENTMEMORY_INJECT_CONTEXT=true`**: Controls whether session-start context is injected into Claude's prompt. Set to `false` (default) for pure bridge usage without additional context injection.

## Implementation Examples

### Importing MEMORY.md into agentmemory

To push Claude's local memory into agentmemory, send an HTTP POST request to the MCP server endpoint with `direction: "import"`:

```typescript
// Triggered from a Claude Code hook or external script
await fetch("http://localhost:49134/mcp/tools/memory_claude_bridge_sync", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    direction: "import",
    filePath: "/home/user/.claude/projects/my-project/MEMORY.md"
  })
});

```

This reads the specified [`MEMORY.md`](https://github.com/rohitg00/agentmemory/blob/main/MEMORY.md) file, converts each line to a JSONL observation, and persists it through the `mem::remember` storage function.

### Exporting agentmemory to MEMORY.md

To update Claude's local file with the current state of agentmemory, use the export direction and write the response to disk:

```typescript
import fetch from "node-fetch";
import fs from "fs";

async function exportToMemoryMd() {
  const res = await fetch(
    "http://localhost:49134/mcp/tools/memory_claude_bridge_sync",
    {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ direction: "export" })
    }
  );

  if (!res.ok) throw new Error(`Bridge error: ${res.statusText}`);

  const jsonl = await res.text();
  fs.writeFileSync(
    "/home/user/.claude/projects/my-project/MEMORY.md",
    jsonl
  );
}

exportToMemoryMd().catch(console.error);

```

This retrieves the full memory graph as a JSONL stream and overwrites the target [`MEMORY.md`](https://github.com/rohitg00/agentmemory/blob/main/MEMORY.md) file, ensuring Claude Code loads the latest persistent context on its next initialization.

### Using the CLI Shortcut

For manual imports without writing custom scripts, use the built-in CLI command which internally invokes the same MCP tool:

```bash
npx @agentmemory/agentmemory import-jsonl \
  ~/.claude/projects/my-project/MEMORY.md

```

## Key Source Files

Understanding the implementation requires familiarity with these specific files in the `rohitg00/agentmemory` repository:

- **[[`src/mcp/tools-registry.ts`](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/tools-registry.ts)](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/tools-registry.ts)**: Defines the `memory_claude_bridge_sync` tool name, description, and input schema.
- **[[`src/mcp/server.ts`](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/server.ts)](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/server.ts)**: Contains the request router that handles the `memory_claude_bridge_sync` case and delegates to import or export logic.
- **[[`src/functions/export-import.ts`](https://github.com/rohitg00/agentmemory/blob/main/src/functions/export-import.ts)](https://github.com/rohitg00/agentmemory/blob/main/src/functions/export-import.ts)**: Implements the JSONL serialization for exports and the parsing logic for imports.
- **[[`plugin/.claude-plugin/plugin.json`](https://github.com/rohitg00/agentmemory/blob/main/plugin/.claude-plugin/plugin.json)](https://github.com/rohitg00/agentmemory/blob/main/plugin/.claude-plugin/plugin.json)**: Advertises available tools to Claude Code.

## Summary

- **The `memory_claude_bridge_sync` tool** provides the official integration point between agentmemory and Claude Code's MEMORY.md file.
- **Bidirectional sync** supports importing CLI chat history into agentmemory and exporting the vector database back to JSONL format.
- **MCP architecture** allows invocation from Claude hooks, custom scripts, or the provided CLI wrapper.
- **Key files** include the tools registry for schema definition and [`export-import.ts`](https://github.com/rohitg00/agentmemory/blob/main/export-import.ts) for data transformation logic.

## Frequently Asked Questions

### What is the `memory_claude_bridge_sync` tool?

The `memory_claude_bridge_sync` tool is a core MCP tool registered in [`src/mcp/tools-registry.ts`](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/tools-registry.ts) that facilitates bidirectional data exchange between Claude Code's local MEMORY.md file and the agentmemory persistent storage system. It accepts `direction` and `filePath` parameters to determine whether to import from or export to the specified file.

### How does the import direction handle existing data?

When importing with `direction: "import"`, the tool reads the provided MEMORY.md path and parses each line as a JSONL observation. These observations are then stored via the `mem::remember` function, which typically appends to or updates the existing memory graph in agentmemory without duplicating entries that match existing vector signatures.

### Can I automate synchronization between the two systems?

Yes. Because the bridge exposes standard HTTP endpoints through the MCP server running on localhost (default port 49134), you can schedule periodic syncs using cron jobs, Git hooks, or Claude Code's session lifecycle hooks. The tool is designed to be called programmatically from any environment that can reach the MCP server.

### Where is the actual JSONL conversion logic implemented?

The JSONL export pipeline is implemented in [[`src/functions/export-import.ts`](https://github.com/rohitg00/agentmemory/blob/main/src/functions/export-import.ts)](https://github.com/rohitg00/agentmemory/blob/main/src/functions/export-import.ts), which contains the `mem::exportAll` function used during export operations. For imports, the parsing logic resides in the same file but is accessed through the import pathway defined in [`src/mcp/server.ts`](https://github.com/rohitg00/agentmemory/blob/main/src/mcp/server.ts).