Roo Code Memory Bank MCP Server

Integrations

  • Manages a project memory bank using Markdown files, providing tools to initialize, read, and append to structured context files that maintain project knowledge across sessions.

  • Serves as the runtime environment for the memory bank system, allowing file operations to create, check, read, and update the contextual knowledge base.

Roo Code Memory Bank MCP Server

This project implements the core functionality of the Roo Code Memory Bank system as a Model Context Protocol (MCP) server. It allows AI assistants to maintain project context across sessions by interacting with a file-based memory bank using structured MCP tools.

Features

This MCP server provides the following tools:

  • initialize_memory_bank: Creates the memory-bank/ directory and standard .md files (productContext.md, activeContext.md, progress.md, decisionLog.md, systemPatterns.md) with initial templates.
    • Input: (Optional) { "project_brief_content": string }
    • Output: { "status": "success" | "error", "messages"?: string[], "message"?: string }
  • check_memory_bank_status: Checks if the memory-bank/ directory exists and lists the .md files within it.
    • Input: {}
    • Output: { "exists": boolean, "files": string[] }
  • read_memory_bank_file: Reads the full content of a specified memory bank file.
    • Input: { "file_name": string }
    • Output: { "content": string } or error object.
  • append_memory_bank_entry: Appends a new, timestamped entry to a specified file, optionally under a specific markdown header. Creates the file if it doesn't exist.
    • Input: { "file_name": string, "entry": string, "section_header"?: string }
    • Output: { "status": "success" | "error", "message": string }

Prerequisites

  • Node.js (v18 or later recommended)
  • npm (usually included with Node.js)
  • An MCP client environment (like the one used by Cline) capable of managing and launching MCP servers.

Installation

  1. Clone the repository:
    git clone https://github.com/IncomeStreamSurfer/roo-code-memory-bank-mcp-server.git cd roo-code-memory-bank-mcp-server
  2. Install dependencies:
    npm install
  3. Build the project:
    npm run build
    This compiles the TypeScript code into JavaScript in the dist/ directory.

Configuration (for Cline MCP Client)

To make this server available to your AI assistant (like Cline), you need to add its configuration to your MCP settings file (e.g., cline_mcp_settings.json).

Find the mcpServers object in your settings file and add the following entry:

{ "mcpServers": { // ... other server configurations ... "roo-code-memory-bank-mcp": { "autoApprove": [ "initialize_memory_bank", "check_memory_bank_status", "read_memory_bank_file", "append_memory_bank_entry" ], "disabled": false, "timeout": 60, "command": "node", // Or "cmd.exe" with "/c node ..." on Windows if needed "args": [ // IMPORTANT: Replace this path with the actual absolute path // to the compiled index.js file on your system "/path/to/your/cloned/repo/roo-code-memory-bank-mcp-server/dist/index.js" ], "env": {}, "transportType": "stdio" } // ... other server configurations ... } }

Important: Replace /path/to/your/cloned/repo/ with the correct absolute path to where you cloned the repository on your machine. Ensure the path separator is correct for your operating system (e.g., use backslashes \ on Windows).

Running the Server

You don't typically need to run the server manually. The MCP client (like Cline) will automatically start the server using the command and args specified in the configuration file when one of its tools is called for the first time.

If you want to test it manually, you can run npm start from the project directory.

Usage

The AI assistant interacts with the server using the defined tools. The typical workflow involves:

  1. Checking the memory bank status (check_memory_bank_status).
  2. Initializing if needed (initialize_memory_bank).
  3. Reading relevant files (read_memory_bank_file) to gain context.
  4. Appending entries (append_memory_bank_entry) as decisions are made or progress occurs.

The memory-bank/ directory will be created in the same directory where the server process is started (which should be the root of this project directory when launched via the MCP client configuration).

Custom instructions

Set these instructions inside Roo

You must use MCPs where needed

I have a specific MCP flow:

Use context7 to find any relevant documentation pieces you will need for this process, ensure to feed any relevant knoweldege to any relevant subtasks - use context7 at all times to do research on important documentation if you're unsure of something Use google maps mcp in order to search for + - this will allow us to find the basic businesses we need to accomplish our task Use brave search mcp to find URLs to scrape Use fetch mcp with fetch_txt and fetch_markdown to find text and images on pages in order to convert into JSON files and create something in-depth Use openrouter search to find general sentiment of topics, reviews, etc.

Utilize the roo-code-memory-bank-mcp server to maintain project context:

  • At the start of a task or significant subtask, use check_memory_bank_status.
  • If the memory bank exists (exists: true), use read_memory_bank_file for relevant files (e.g., productContext.md, activeContext.md) to load the current project context.
  • Incorporate this loaded context into your planning and execution.
  • When making significant decisions, progress updates, or architectural changes, use append_memory_bank_entry to record the information in the appropriate file (decisionLog.md, progress.md, etc.), ensuring context persistence.
  • If the memory bank doesn't exist, consider using initialize_memory_bank if appropriate for the project.

You must be authenticated.

A
security – no known vulnerabilities
A
license - permissive license
A
quality - confirmed to work

local-only server

The server can only run on the client's local machine because it depends on local resources.

Enables AI assistants to maintain persistent project context across sessions by storing and retrieving structured information in markdown files organized in a memory bank directory.

  1. Features
    1. Prerequisites
      1. Installation
        1. Configuration (for Cline MCP Client)
          1. Running the Server
            1. Usage
              1. Custom instructions

            Related MCP Servers

            • A
              security
              A
              license
              A
              quality
              A Model Context Protocol implementation that enables AI assistants to interact with markdown documentation files, providing capabilities for document management, metadata handling, search, and documentation health analysis.
              Last updated -
              14
              346
              11
              TypeScript
              MIT License
              • Apple
              • Linux
            • A
              security
              A
              license
              A
              quality
              Provides tools for interacting with Targetprocess, a project management and agile planning platform, enabling AI assistants to search, create, and update project entities with proper validation.
              Last updated -
              5
              TypeScript
              MIT License
            • A
              security
              A
              license
              A
              quality
              Memory Bank Server provides a set of tools and resources for AI assistants to interact with Memory Banks. Memory Banks are structured repositories of information that help maintain context and track progress across multiple sessions.
              Last updated -
              15
              111
              13
              TypeScript
              MIT License
            • -
              security
              A
              license
              -
              quality
              A server for managing project documentation and context across Claude AI sessions through global and branch-specific memory banks, enabling consistent knowledge management with structured JSON document storage.
              Last updated -
              317
              7
              TypeScript
              MIT License

            View all related MCP servers

            ID: 0io7cvii44