Skip to content
Back to search

memory-bank-mcp

A Model Context Protocol (MCP) server implementation for remote memory bank management, inspired by Cline Memory Bank.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/alioshr--memory-bank-mcp/badge.svg)](/listings/alioshr--memory-bank-mcp)

HTML

<a href="/listings/alioshr--memory-bank-mcp"><img src="/api/listings/alioshr--memory-bank-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

To install Memory Bank Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@alioshr/memory-bank-mcp):

npx -y @smithery/cli install @alioshr/memory-bank-mcp --client claude

This will set up the MCP server configuration automatically. Alternatively, you can configure the server manually as described in the Configuration section below.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 232 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Memory Bank MCP Server
  2. [![smithery badge](https://smithery.ai/badge/@alioshr/memory-bank-mcp)](https://smithery.ai/server/@alioshr/memory-bank-mcp)
  3. [![npm version](https://badge.fury.io/js/%40allpepper%2Fmemory-bank-mcp.svg)](https://www.npmjs.com/package/@allpepper/memory-bank-mcp)
  4. [![npm downloads](https://img.shields.io/npm/dm/@allpepper/memory-bank-mcp.svg)](https://www.npmjs.com/package/@allpepper/memory-bank-mcp)
  5. <a href="https://glama.ai/mcp/servers/ir18x1tixp"><img width="380" height="200" src="https://glama.ai/mcp/servers/ir18x1tixp/badge" alt="Memory Bank Server MCP server" /></a>
  6. A Model Context Protocol (MCP) server implementation for remote memory bank management, inspired by [Cline Memory Bank](https://github.com/nickbaumann98/cline_docs/blob/main/prompting/custom%20instructions%20library/cline-memory-bank.md).
  7. ## Overview
  8. The Memory Bank MCP Server transforms traditional file-based memory banks into a centralized service that:
  9. - Provides remote access to memory bank files via MCP protocol
  10. - Enables multi-project memory bank management
  11. - Maintains consistent file structure and validation
  12. - Ensures proper isolation between project memory banks
  13. ## Features
  14. - **Multi-Project Support**
  15. - Project-specific directories
  16. - File structure enforcement
  17. - Path traversal prevention
  18. - Project listing capabilities
  19. - File listing per project
  20. - **Remote Accessibility**
  21. - Full MCP protocol implementation
  22. - Type-safe operations
  23. - Proper error handling
  24. - Security through project isolation
  25. - **Core Operations**
  26. - Read/write/update memory bank files
  27. - List available projects
  28. - List files within projects
  29. - Project existence validation
  30. - Safe read-only operations
  31. ## Installation
  32. To install Memory Bank Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@alioshr/memory-bank-mcp):
  33. ```bash
  34. npx -y @smithery/cli install @alioshr/memory-bank-mcp --client claude
  35. ```
  36. This will set up the MCP server configuration automatically. Alternatively, you can configure the server manually as described in the Configuration section below.
  37. ## Quick Start
  38. 1. Configure the MCP server in your settings (see Configuration section below)
  39. 2. Start using the memory bank tools in your AI assistant
  40. ## Using with Cline/Roo Code
  41. The memory bank MCP server needs to be configured in your Cline MCP settings file. The location depends on your setup:
  42. - For Cline extension: `~/Library/Application Support/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
  43. - For Roo Code VS Code extension: `~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json`
  44. Add the following configuration to your MCP settings:
  45. ```json
  46. {
  47. "allpepper-memory-bank": {
  48. "command": "npx",
  49. "args": ["-y", "@allpepper/memory-bank-mcp"],
  50. "env": {
  51. "MEMORY_BANK_ROOT": "<path-to-bank>"
  52. },
  53. "disabled": false,
  54. "autoApprove": [
  55. "memory_bank_read",
  56. "memory_bank_write",
  57. "memory_bank_update",
  58. "list_projects",
  59. "list_project_files"
  60. ]
  61. }
  62. }
  63. ```
  64. ### Configuration Details
  65. - `MEMORY_BANK_ROOT`: Directory where project memory banks will be stored (e.g., `/path/to/memory-bank`)
  66. - `disabled`: Set to `false` to enable the server
  67. - `autoApprove`: List of operations that don't require explicit user approval:
  68. - `memory_bank_read`: Read memory bank files
  69. - `memory_bank_write`: Create new memory bank files
  70. - `memory_bank_update`: Update existing memory bank files
  71. - `list_projects`: List available projects
  72. - `list_project_files`: List files within a project
  73. ## Using with Cursor
  74. For Cursor, open the settings -> features -> add MCP server -> add the following:
  75. ```shell
  76. env MEMORY_BANK_ROOT=<path-to-bank> npx -y @allpepper/memory-bank-mcp@latest
  77. ```
  78. ## Using with Claude
  79. - Claude desktop config file: `~/Library/Application Support/Claude/claude_desktop_config.json`
  80. - Claude Code config file: `~/.claude.json`
  81. 1. Locate the config file
  82. 3. Locate the property called `mcpServers`
  83. 4. Paste this:
  84. ```
  85. "allPepper-memory-bank": {
  86. "type": "stdio",
  87. "command": "npx",
  88. "args": [
  89. "-y",
  90. "@allpepper/memory-bank-mcp@latest"
  91. ],
  92. "env": {
  93. "MEMORY_BANK_ROOT": "YOUR PATH"
  94. }
  95. }
  96. ```
  97. ## Custom AI instructions
  98. This section contains the instructions that should be pasted on the AI custom instructions, either for Cline, Claude or Cursor, or any other MCP client. You should copy and paste these rules. For reference, see [custom-instructions.md](custom-instructions.md) which contains these rules.
  99. ## Development
  100. Basic development commands:
  101. ```bash
  102. # Install dependencies
  103. npm install
  104. # Build the project
  105. npm run build
  106. # Run tests
  107. npm run test
  108. # Run tests in watch mode
  109. npm run test:watch
  110. # Run the server directly with ts-node for quick testing
  111. npm run dev
  112. ```
  113. ### Running with Docker
  114. 1. Build the Docker image:
  115. ```bash
  116. docker build -t memory-bank-mcp:local .
  117. ```
  118. 2. Run the Docker container for testing:
  119. ```bash
  120. docker run -i --rm \
  121. -e MEMORY_BANK_ROOT="/mnt/memory_bank" \
  122. -v /path/to/memory-bank:/mnt/memory_bank \
  123. --entrypoint /bin/sh \
  124. memory-bank-mcp:local \
  125. -c "ls -la /mnt/memory_bank"
  126. ```
  127. 3. Add MCP configuration, example for Roo Code:
  128. ```json
  129. "allpepper-memory-bank": {
  130. "command": "docker",
  131. "args": [
  132. "run", "-i", "--rm",
  133. "-e",
  134. "MEMORY_BANK_ROOT",
  135. "-v",
  136. "/path/to/memory-bank:/mnt/memory_bank",
  137. "memory-bank-mcp:local"
  138. ],
  139. "env": {
  140. "MEMORY_BANK_ROOT": "/mnt/memory_bank"
  141. },
  142. "disabled": false,
  143. "alwaysAllow": [
  144. "list_projects",
  145. "list_project_files",
  146. "memory_bank_read",
  147. "memory_bank_update",
  148. "memory_bank_write"
  149. ]
  150. }
  151. ```
  152. ## Contributing
  153. Contributions are welcome! Please follow these steps:
  154. 1. Fork the repository
  155. 2. Create a feature branch (`git checkout -b feature/amazing-feature`)
  156. 3. Commit your changes (`git commit -m 'Add amazing feature'`)
  157. 4. Push to the branch (`git push origin feature/amazing-feature`)
  158. 5. Open a Pull Request
  159. ### Development Guidelines
  160. - Use TypeScript for all new code
  161. - Maintain type safety across the codebase
  162. - Add tests for new features
  163. - Update documentation as needed
  164. - Follow existing code style and patterns
  165. ### Testing
  166. - Write unit tests for new features
  167. - Include multi-project scenario tests
  168. - Test error cases thoroughly
  169. - Validate type constraints
  170. - Mock filesystem operations appropriately
  171. ## License
  172. This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
  173. ## Acknowledgments
  174. This project implements the memory bank concept originally documented in the [Cline Memory Bank](https://github.com/nickbaumann98/cline_docs/blob/main/prompting/custom%20instructions%20library/cline-memory-bank.md), extending it with remote capabilities and multi-project support.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.