npm package: @iflow-mcp/roo-code-memory-bank-mcp-server
Description: MCP server for Roo Code Memory Bank functionality
Latest version: 0.1.0

# Roo Code Memory Bank MCP Server

This project implements the core functionality of the [Roo Code Memory Bank](https://github.com/GreatScottyMac/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:**
    ```bash
    git clone https://github.com/IncomeStreamSurfer/roo-code-memory-bank-mcp-server.git
    cd roo-code-memory-bank-mcp-server
    ```
2.  **Install dependencies:**
    ```bash
    npm install
    ```
3.  **Build the project:**
    ```bash
    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:

```json
{
  "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 <niche> + <county> - 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.