Memory Bank MCP Server

The Memory Bank is organized into a hierarchy of core and custom files. Understanding the relationships is critical for correct access and updates.

Core File Hierarchy

• Foundation (Purple): projectbrief.md (Core requirements/goals). This feeds into all other context files.
• Context (Blue):
  • productContext.md (Problem context/solutions)
  • systemPatterns.md (Architecture/patterns)
  • techContext.md (Tech stack/setup)
  • activeContext.md (Current focus/decisions). This file is informed by all other context files.
• Status (Green): progress.md (Status/roadmap). Tracks implementation based on the active context.

Custom Files (Dashed)

You can add custom documentation as needed (e.g., features/*.md, api/*.md, deployment/*.md). These must be referenced in activeContext.md when added.

Access and Update Patterns

• Access Pattern: Always read files in hierarchical order (Foundation $\rightarrow$ Context $\rightarrow$ Status).
• Update Pattern: Always update in reverse order (progress.md $\rightarrow$ activeContext.md $\rightarrow$ others).

If you prefer running the server in a containerized environment, follow these steps:

1. Build the image: docker build -t memory-bank-mcp:local .

2. Test the container: Run a command to verify the mount and environment variables.

3. Configure MCP client (e.g., Roo Code) to use Docker: Map the local memory bank directory to /mnt/memory_bank inside the container and set the MEMORY_BANK_ROOT environment variable to /mnt/memory_bank.

"allpepper-memory-bank": {
  "command": "docker",
  "args": [
    "run", "-i", "--rm",
    "-e", 
    "MEMORY_BANK_ROOT",
    "-v", 
    "/path/to/memory-bank:/mnt/memory_bank",
    "memory-bank-mcp:local"
  ],
  "env": {
    "MEMORY_BANK_ROOT": "/mnt/memory_bank"
  },
  "disabled": false,
  "alwaysAllow": [
    "list_projects",
    "list_project_files",
    "memory_bank_read",
    "memory_bank_update",
    "memory_bank_write"
  ]
}

To use the server with Cline or Roo Code, add the allpepper-memory-bank configuration to your MCP settings file.

File Locations:

• Cline extension: ~/Library/Application Support/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
• Roo Code VS Code extension: ~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json

Configuration Schema:

• MEMORY_BANK_ROOT: The absolute path to the directory where your project memory banks are stored.
• disabled: Set to false to enable the server.
• autoApprove: A list of tools that can run without explicit user confirmation. Recommended tools include memory_bank_read, memory_bank_write, memory_bank_update, list_projects, and list_project_files.

{
  "allpepper-memory-bank": {
    "command": "npx",
    "args": ["-y", "@allpepper/memory-bank-mcp"],
    "env": {
      "MEMORY_BANK_ROOT": "<path-to-bank>"
    },
    "disabled": false,
    "autoApprove": [
      "memory_bank_read",
      "memory_bank_write",
      "memory_bank_update",
      "list_projects",
      "list_project_files"
    ]
  }
}

The McpRouterAdapter class is used to register and manage Model Context Protocol (MCP) tools. It maps tool names to their respective schemas (of type Tool) and asynchronous request handlers.

Key methods for managing tools:

• setTool({ schema, handler }): Registers a new tool. It accepts an object containing a schema (the Tool definition) and a handler (an async function that processes MCPRequest and returns MCPResponse). This method is chainable.
• getToolHandler(name): Retrieves the async handler for a specific tool by its name.
• getToolsSchemas(): Returns an array of all registered Tool schemas.
• getToolCapabilities(): Returns an object mapping tool names to their corresponding Tool schemas, useful for exposing available capabilities to an MCP client.

import { McpRouterAdapter } from './path-to-adapter';
import { Tool } from "@modelcontextprotocol/sdk/types.js";

const adapter = new McpRouterAdapter();

// Define a tool schema
const myToolSchema: Tool = {
  name: "example_tool",
  description: "An example tool",
  inputSchema: { type: "object", properties: {} }
};

// Define a handler
const myHandler = async (request: any) => {
  return { content: [{ type: "text", text: "Hello from tool" }] };
};

// Register the tool
adapter.setTool({
  schema: myToolSchema,
  handler: Promise.resolve(myHandler)
});

// Retrieve capabilities
const capabilities = adapter.getToolCapabilities();
// Result: { "example_tool": myToolSchema }