MCP 服务器

MCP Memory Server

A Model Context Protocol server that provides knowledge graph-based persistent memory for LLMs, allowing them to store, retrieve, and reason about information across multiple conversations and sessions.

Tools

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

README

MCP Memory Server

A Model Context Protocol (MCP) server implementation that provides persistent memory capabilities for Large Language Models.

Overview

This repository contains a reference implementation of the Model Context Protocol Memory Server. The server implements a knowledge graph-based persistent memory system that enables LLMs to store, retrieve, and reason about information across conversations and sessions.

Features

Knowledge Graph Storage: Persistent graph-based information storage
Entity Management: Create and manage entities and their relationships
Semantic Search: Find relevant information using semantic similarity
Cross-session Memory: Maintain context across different conversations
Memory Operations: Full CRUD operations for memory management

Installation

npm install
npm run build

Usage

# Run the memory server
npx mcp-server-memory

Development

npm run watch

This will start the server in development mode with automatic rebuilding on file changes.

Running the Server

Direct Execution

For development and testing, you can run the server directly:

# Build first (if not already built)
npm run build

# Run the server
node dist/index.js

Using npm binary

After building, you can use the npm binary name:

npx mcp-server-memory

Background Process

The server runs continuously and communicates via stdio (standard input/output), which is the standard for MCP servers.

Testing with MCP Inspector

The MCP Inspector is an excellent tool for testing and debugging your memory server during development:

Start the Inspector

npx @modelcontextprotocol/inspector node dist/index.js

This will:

Start a proxy server (typically on 127.0.0.1:6277)
Launch the web-based inspector interface (typically at http://127.0.0.1:6274)
Provide a session token for authentication

Using the Inspector

The Inspector provides several tabs for testing your server:

Resources tab: View and test memory resources
Tools tab: Test memory management tools (create, update, delete entities)
Prompts tab: Test any prompt templates
Notifications pane: Monitor server logs and messages

Development Workflow

Make changes to src/index.ts
Run npm run build to rebuild
Start the Inspector: npx @modelcontextprotocol/inspector node dist/index.js
Test your changes in the web interface
Check the notifications pane for any errors

Integration with MCP Clients

To use this server with MCP clients (like Claude Desktop), add it to your client configuration:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/path/to/your/mcp-memory-server/dist/index.js"]
    }
  }
}

Or if published to npm:

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

Model Context Protocol

The Model Context Protocol (MCP) is an open standard that enables seamless integration between AI applications and external data sources and tools. Learn more at modelcontextprotocol.io.