Skip to content
Back to search

memory-bank-MCP

Memory Bank is an MCP server that helps teams create, manage, and access structured project documentation. It generates and maintains a set of interconnected Markdown documents that capture different aspects of project knowledge, from high-level goals to technical details and day-to-day progress.

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/tuncer-byte--memory-bank-mcp/badge.svg)](/listings/tuncer-byte--memory-bank-mcp)

HTML

<a href="/listings/tuncer-byte--memory-bank-mcp"><img src="/api/listings/tuncer-byte--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.

# Clone the repository
git clone https://github.com/tuncer-byte/memory-bank-mcp.git
cd memory-bank-mcp

# Install dependencies
npm install

# (Optional) Create .env file with your Gemini API key
echo "GEMINI_API_KEY=your_api_key_here" > .env

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 · 189 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
  2. <div align="center">
  3. <img src="https://github.com/tuncer-byte/byte/blob/main/media/icons/icon-white.png" height="128">
  4. <h1>Memory Bank MCP</h1>
  5. <p>
  6. <b>Structured project knowledge management for LLMs via Model Context Protocol (MCP)</b>
  7. </p>
  8. </div>
  9. <a href="https://glama.ai/mcp/servers/@tuncer-byte/memory-bank-MCP">
  10. <img width="380" height="200" src="https://glama.ai/mcp/servers/@tuncer-byte/memory-bank-MCP/badge" alt="Memory Bank MCP server" />
  11. </a>
  12. ---
  13. > **Note:** This is not a traditional Node.js application. Memory Bank MCP is an **MCP server**—a component in the [Model Context Protocol](https://modelcontextprotocol.io/introduction) ecosystem. It exposes project knowledge to LLM-powered agents and tools using a standardized protocol, enabling seamless integration with AI clients (e.g., Claude Desktop, IDEs, or custom LLM agents).
  14. ---
  15. ## What is Model Context Protocol (MCP)?
  16. MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI: it provides a universal way to connect AI models to data sources and tools, both locally and remotely. MCP enables:
  17. - **Plug-and-play integrations** between LLMs, data, and tools
  18. - **Switching between LLM providers** with minimal friction
  19. - **Secure, modular architecture** for building AI workflows
  20. Learn more: [MCP Introduction](https://modelcontextprotocol.io/introduction)
  21. ## About Memory Bank MCP
  22. Memory Bank MCP is an **MCP server** that helps teams create, manage, and access structured project documentation. It generates and maintains interconnected Markdown documents capturing all aspects of project knowledge, from high-level goals to technical details and daily progress. It is designed to be accessed by MCP-compatible clients and LLM agents.
  23. ## Features
  24. - **AI-Generated Documentation**: Uses Gemini API to generate and update project documentation
  25. - **Structured Knowledge System**: Maintains six core document types in a hierarchical structure
  26. - **MCP Server**: Implements the Model Context Protocol for integration with LLM agents and tools
  27. - **Customizable Storage**: Choose where your Memory Bank directory is created
  28. - **Document Templates**: Pre-defined templates for project brief, product context, system patterns, etc.
  29. - **AI-Assisted Updates**: Update documents manually or regenerate them with AI
  30. - **Advanced Querying**: Search across all documents with context-aware relevance ranking
  31. ## Installation
  32. ```bash
  33. # Clone the repository
  34. git clone https://github.com/tuncer-byte/memory-bank-mcp.git
  35. cd memory-bank-mcp
  36. # Install dependencies
  37. npm install
  38. # (Optional) Create .env file with your Gemini API key
  39. echo "GEMINI_API_KEY=your_api_key_here" > .env
  40. ```
  41. ## Usage
  42. > **Note:** Memory Bank MCP is intended to be run as an MCP server, not as a standalone app. You typically launch it as part of an MCP workflow, and connect to it from an MCP-compatible client (such as Claude Desktop or your own LLM agent).
  43. ### Development Mode
  44. ```bash
  45. npm run dev
  46. ```
  47. ### Production Mode
  48. ```bash
  49. npm run build
  50. npm run start
  51. ```
  52. ### MCP Integration
  53. To connect Memory Bank MCP to your MCP client, add the following to your `mcp.json` configuration:
  54. ```json
  55. {
  56. "memoryBank": {
  57. "command": "node",
  58. "args": ["/path/to/memory-bank-mcp/dist/index.js"],
  59. "env": {
  60. "GEMINI_API_KEY": "your_gemini_api_key_here"
  61. }
  62. }
  63. }
  64. ```
  65. Replace `/path/to/memory-bank-mcp/dist/index.js` with the absolute path to your built file, and add your Gemini API key if needed.
  66. ---
  67. ## MCP Tools Exposed by Memory Bank
  68. Memory Bank MCP provides the following tools via the Model Context Protocol:
  69. ### `initialize_memory_bank`
  70. Creates a new Memory Bank structure with all document templates.
  71. **Parameters:**
  72. - `goal` (string): Project goal description (min 10 characters)
  73. - `geminiApiKey` (string, optional): Gemini API key for document generation
  74. - `location` (string, optional): Absolute path where memory-bank folder will be created
  75. **Example:**
  76. ```javascript
  77. await callTool({
  78. name: "initialize_memory_bank",
  79. arguments: {
  80. goal: "Building a self-documenting AI-powered software development assistant",
  81. location: "/Users/username/Documents/projects/ai-assistant"
  82. }
  83. });
  84. ```
  85. ### `update_document`
  86. Updates a specific document in the Memory Bank.
  87. **Parameters:**
  88. - `documentType` (enum): One of: `projectbrief`, `productContext`, `systemPatterns`, `techContext`, `activeContext`, `progress`
  89. - `content` (string, optional): New content for the document
  90. - `regenerate` (boolean, default: false): Whether to regenerate the document using AI
  91. **Example:**
  92. ```javascript
  93. await callTool({
  94. name: "update_document",
  95. arguments: {
  96. documentType: "projectbrief",
  97. content: "# Project Brief\n\n## Purpose\nTo develop an advanced and user-friendly AI..."
  98. }
  99. });
  100. ```
  101. ### `query_memory_bank`
  102. Searches across all documents with context-aware relevance ranking.
  103. **Parameters:**
  104. - `query` (string): Search query (min 5 characters)
  105. **Example:**
  106. ```javascript
  107. await callTool({
  108. name: "query_memory_bank",
  109. arguments: {
  110. query: "system architecture components"
  111. }
  112. });
  113. ```
  114. ### `export_memory_bank`
  115. Exports all Memory Bank documents.
  116. **Parameters:**
  117. - `format` (enum, default: "folder"): Export format, either "json" or "folder"
  118. - `outputPath` (string, optional): Custom output path for the export
  119. **Example:**
  120. ```javascript
  121. await callTool({
  122. name: "export_memory_bank",
  123. arguments: {
  124. format: "json",
  125. outputPath: "/Users/username/Documents/exports"
  126. }
  127. });
  128. ```
  129. ## Document Types
  130. Memory Bank organizes project knowledge into six core document types:
  131. 1. **Project Brief** (`projectbrief.md`): Core document defining project objectives, scope, and vision
  132. 2. **Product Context** (`productContext.md`): Documents product functionality from a user perspective
  133. 3. **System Patterns** (`systemPatterns.md`): Establishes system architecture and component relationships
  134. 4. **Tech Context** (`techContext.md`): Specifies technology stack and implementation details
  135. 5. **Active Context** (`activeContext.md`): Tracks current tasks, open issues, and development focus
  136. 6. **Progress** (`progress.md`): Documents completed work, milestones, and project history
  137. ## License
  138. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

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