# mcasdfgf/mcp-roo-memory [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/mcasdfgf/mcp-roo-memory  
**GitHub Stars:** 1  
**npm Downloads (last month):** 5094  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/mcasdfgf-mcp-roo-memory

## Description
Persistent fractal graph memory for AI coding agents via MCP. Semantic vector search, hot/cold/archive context tiers, decision tracking, and Docker-based deployment with Qdrant.

## Tools
Capabilities this server exposes over MCP:

- **desktop_open** — Open/restore a workspace session
- **desktop_focus** — Bring a node into hot context
- **desktop_history** — Get navigation history for a workspace
- **graph_add_node** — Store any knowledge: entity, fact, decision, task...
- **graph_get_node** — Retrieve a node with its relations
- **graph_add_relation** — Create a relation between two nodes
- **graph_traverse** — Walk the graph from a starting node
- **graph_walk** — Walk along a reasoning chain
- **graph_decompose** — Break a task into structured subtasks
- **graph_update_node** — Update a node's data in-place
- **graph_supersede** — Replace outdated knowledge (keeps history)
- **graph_delete_node** — Delete a node and its vector
- **vector_search** — Find things by meaning, across 50+ languages
- **vector_store** — Store text with automatic vectorization
- **graph_search** — Hybrid: semantic + graph subgraph expansion
- **temporal_walk** — Chronological graph traversal (time axis)
- **session_timeline** — Flat timeline of all events in a session

## Claude Desktop Quick Installation
Heuristic fallback — verify the package name and runner against the repository README before running it. Uses `npx` (confidence: low):

```json
"mcpServers": {
  "mcp-roo-memory": {
    "command": "npx",
    "args": ["-y","mcasdfgf-mcp-roo-memory"]
  }
}
```

## Documentation

## What mcasdfgf/mcp-roo-memory MCP server does

mcasdfgf/mcp-roo-memory MCP server provides persistent memory for Roo Code through the Model Context Protocol. It represents stored information as a graph rather than as unrelated text fragments. Nodes can represent entities, facts, decisions, tasks, or other knowledge, and relations connect those nodes for retrieval and traversal.

The server also maintains a desktop-style context view with hot, cold, and archive tiers. Agents can restore a workspace, focus a node into active context, and inspect navigation history. This is intended to limit how much stored information is brought into an agent's current context while retaining older material for search.

## How it works

Graph data and history are stored in SQLite. Semantic indexing uses Qdrant and fastembed, allowing vector searches based on meaning rather than exact keywords. The README states that semantic search supports more than 50 languages. Hybrid graph search combines semantic retrieval with expansion into related graph subgraphs.

Knowledge can be changed in place, replaced while preserving its history, or removed together with its vector entry. Relations can be traversed from a starting node, followed as reasoning chains, or explored chronologically. The temporal features include chronological graph walks, session timelines, and time-based vector filtering.

Workspace behavior can be global or project-specific. Desktop operations and graph writes use the selected project workspace, while vector searches can either span projects or be limited to one workspace through a workspace identifier.

## Setup and configuration

The recommended deployment uses Docker Compose. Cloning the repository and running `docker compose up -d` starts a Qdrant container on port 6333 and a Cortex container that waits for MCP connections. Roo Code can then be configured to invoke the server inside the running container with Docker and `python3 -m src.cortex`.

For isolated project memory, the repository's `.roo/` directory can be copied into a project and its MCP configuration can include a project-specific `--workspace` value. The included rules and instructions describe memory lifecycle behavior for several Roo Code modes.

A native installation is also documented for Python 3.11 or later. It uses an editable install from the cloned repository, but Qdrant remains a separate requirement and must still be run, such as through Docker. Native MCP configuration supports `CORTEX_DB_PATH`, `CORTEX_QDRANT_HOST`, and `CORTEX_QDRANT_PORT`.

## Tools and capabilities

mcasdfgf/mcp-roo-memory MCP server exposes tools for:

- Opening, focusing, and inspecting workspace sessions.
- Creating, reading, updating, superseding, and deleting graph nodes.
- Adding relations, traversing graphs, and walking reasoning chains.
- Decomposing tasks into structured subtasks.
- Storing text with automatic vectorization and searching by meaning.
- Combining semantic search with graph expansion.
- Walking the graph by time and retrieving a session timeline.

## Limitations and notes

The repository labels the software as experimental and a proof of concept. It is provided without warranty, so it should be evaluated before being used as the sole memory system for important workflows. The supplied setup is centered on Roo Code and its MCP configuration; compatibility with other clients is not established by the provided material.

_Full upstream README: https://allmcps.com/mcp/mcasdfgf-mcp-roo-memory/readme_