# Memory [Verified] [Health: Active]

**Category:** 🛠️ Other Tools and Integrations  
**Repository:** https://github.com/modelcontextprotocol/servers/tree/main/src/memory  
**GitHub Stars:** 90510  
**npm Downloads (last month):** 461437  
**Views:** 2  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/memory

## Description
Knowledge graph-based persistent memory system.

## Tools
Capabilities this server exposes over MCP:

- **create_entities** — Create multiple new entities in the knowledge graph
- **create_relations** — Create multiple new relations between entities in the knowledge graph. Relations should be in active voice
- **add_observations** — Add new observations to existing entities in the knowledge graph
- **delete_entities** — Delete multiple entities and their associated relations from the knowledge graph
- **delete_observations** — Delete specific observations from entities in the knowledge graph
- **delete_relations** — Delete multiple relations from the knowledge graph
- **read_graph** — Read the entire knowledge graph
- **search_nodes** — Search for nodes in the knowledge graph based on a query
- **open_nodes** — Open specific nodes in the knowledge graph by their names

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "memory": {
    "command": "npx",
    "args": ["-y","@modelcontextprotocol/server-memory"]
  }
}
```

## Documentation

## What Memory does

The Memory MCP server exposes a knowledge graph as persistent memory for MCP-compatible agents. Information is organized around entities, relationships between entities, and observations attached to existing entities. This structure is useful when an agent needs to record named concepts and their connections instead of handling memory as unstructured text.

The server belongs to the 🧠 Knowledge & Memory category and is implemented as one of the MCP repository’s reference servers. It is intended to demonstrate MCP features and SDK usage, so teams should evaluate whether its behavior and security controls fit their own deployment requirements before using it in production.

## How it works

The Memory MCP server communicates through MCP tools that operate on the knowledge graph. An agent can add entities, connect them with active-voice relations, and attach observations to entities that already exist. It can later search nodes by a query, open specific nodes by name, or read the complete graph.

Graph changes are also exposed as explicit deletion operations. Clients can remove entities together with their associated relations, delete selected observations, or delete multiple relations. This gives an agent separate operations for adding, inspecting, and cleaning up stored knowledge.

The model is deliberately structured: entities represent graph nodes, relations connect nodes, and observations add details to entities. The available material does not specify a separate query language, external data source, authentication mechanism, or storage backend.

## Setup and configuration

The reference package can be started with npx:

```sh
npx -y @modelcontextprotocol/server-memory
```

To use the Memory MCP server with Claude Desktop, add an MCP server entry using `npx` as the command and `-y @modelcontextprotocol/server-memory` as its arguments:

```json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}
```

On Windows, the documented configuration wraps npx with `cmd /c`. No required environment variables or additional configuration values are provided in the reference material.

## Tools and capabilities

The Memory MCP server provides these operations:

- `create_entities`: add multiple entities to the graph.
- `create_relations`: add multiple relations between entities; relations should use active voice.
- `add_observations`: attach new observations to existing entities.
- `delete_entities`: remove multiple entities and their associated relations.
- `delete_observations`: remove specific observations from entities.
- `delete_relations`: remove multiple relations.
- `read_graph`: read the entire knowledge graph.
- `search_nodes`: find graph nodes based on a query.
- `open_nodes`: retrieve specific nodes by name.

These tools support both graph construction and targeted retrieval. The Memory MCP server can therefore support workflows that record facts, connect related items, revisit named nodes, and remove outdated graph data.

## Limitations and notes

This implementation is published as a reference server rather than a production-ready solution. The repository advises developers to assess their own security requirements and add safeguards appropriate to their threat model and use case. The supplied material does not document persistence settings, access controls, backup behavior, concurrency guarantees, or a hosted service.

The repository uses Apache-2.0 for new contributions and retains MIT licensing for existing code, but the provided material does not assign one unambiguous license specifically to this server package.

## Getting started with this Memory MCP server
Always refer to the official documentation for the most accurate and up-to-date information.

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