Memory Custom
The Memory Custom server enables the creation and management of a knowledge graph for LLM interactions with these capabilities:
Create and Manage Entities: Add new nodes to the knowledge graph
Establish Relations: Define connections between entities
Add Observations: Append facts or attributes to existing entities
Delete Data: Remove entities, observations, or relations
Set Memory Paths: Customize file paths for storing memory data
Search and Retrieve: Find nodes based on queries or access specific nodes by name
Read Entire Graph: Access the complete knowledge graph structure
Timestamping: Automatically track when changes occur
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Memory Custom add my meeting with Alex about the Q3 project to memory"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Memory Custom
This project adds new features to the Memory server offered by the MCP team. It allows for the creation and management of a knowledge graph that captures interactions via a language model (LLM).
New Features
1. Custom Memory Paths
Users can now specify different memory file paths for various projects.
Why?: This feature enhances organization and management of memory data, allowing for project-specific memory storage.
2. Timestamping
The server now generates timestamps for interactions.
Why?: Timestamps enable tracking of when each memory was created or modified, providing better context and history for the stored data.
Related MCP server: KG Memory
Getting Started
Prerequisites
Node.js (version 16 or higher)
Installing via Smithery
To install Knowledge Graph Memory Server for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @BRO3886/mcp-memory-custom --client claudeInstallation
Clone the repository:
git clone git@github.com:BRO3886/mcp-memory-custom.git cd mcp-memory-customInstall the dependencies:
npm install
Configuration
Before running the server, you can set the MEMORY_FILE_PATH environment variable to specify the path for the memory file. If not set, the server will default to using memory.json in the same directory as the script.
Running the Server
Updating the mcp server json file
Add this to your claude_desktop_config.json / .cursor/mcp.json file:
{
"mcpServers": {
"memory": {
"command": "node",
"args": ["/path/to/mcp-memory-custom/dist/index.js"]
}
}
}System Prompt changes:
Follow these steps for each interaction:
1. The memoryFilePath for this project is /path/to/memory/project_name.json - always pass this path to the memory file operations (when creating entities, relations, or retrieving memory etc.)
2. User Identification:
- You should assume that you are interacting with default_user
- If you have not identified default_user, proactively try to do so.
3. Memory Retrieval:
- Always begin your chat by saying only "Remembering..." and retrieve all relevant information from your knowledge graph
- Always refer to your knowledge graph as your "memory"
4. Memory
- While conversing with the user, be attentive to any new information that falls into these categories:
a) Basic Identity (age, gender, location, job title, education level, etc.)
b) Behaviors (interests, habits, etc.)
c) Preferences (communication style, preferred language, etc.)
d) Goals (goals, targets, aspirations, etc.)
e) Relationships (personal and professional relationships up to 3 degrees of separation)
5. Memory Update:
- If any new information was gathered during the interaction, update your memory as follows:
a) Create entities for recurring organizations, people, and significant events, add timestamps to wherever required. You can get current timestamp via get_current_time
b) Connect them to the current entities using relations
c) Store facts about them as observations, add timestamps to observations via get_current_time
IMPORTANT: Provide a helpful and engaging response, asking relevant questions to encourage user engagement. Update the memory during the interaction, if required, based on the new information gathered (point 4).Running the Server Locally
To start the Knowledge Graph Memory Server, run:
npm run build
node dist/index.jsThe server will listen for requests via standard input/output.
API Endpoints
The server exposes several tools that can be called with specific parameters:
Get Current Time
Set Memory File Path
Create Entities
Create Relations
Add Observations
Delete Entities
Delete Observations
Delete Relations
Read Graph
Search Nodes
Open Nodes
Acknowledgments
Inspired by the Memory server from Anthropic.
Available Tools
10 toolsadd_observationsC
Add new observations to existing entities in the knowledge graph
Inputs: observations (required), memoryFilePath (required).
create_entitiesC
Create multiple new entities in the knowledge graph
Inputs: entities (required), memoryFilePath (required).
create_relationsC
Create multiple new relations between entities in the knowledge graph. Relations should be in active voice
Inputs: relations (required), memoryFilePath (required).
delete_entitiesC
Delete multiple entities and their associated relations from the knowledge graph
Inputs: entityNames (required), memoryFilePath (required).
delete_observationsC
Delete specific observations from entities in the knowledge graph
Inputs: deletions (required), memoryFilePath (required).
delete_relationsC
Delete multiple relations from the knowledge graph
Inputs: relations (required), memoryFilePath (required).
get_current_timeB
Get the current time
Inputs: no named parameters.
open_nodesC
Open specific nodes in the knowledge graph by their names
Inputs: names (required), memoryFilePath (required).
read_graphC
Read the entire knowledge graph
Inputs: memoryFilePath (required).
search_nodesC
Search for nodes in the knowledge graph based on a query
Inputs: query (required), memoryFilePath (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 10 tools
Most tools have distinct purposes focused on knowledge graph operations, but 'open_nodes' and 'search_nodes' could be confused as both involve accessing nodes. The descriptions clarify that 'open_nodes' retrieves specific nodes by name while 'search_nodes' queries based on content, but the overlap in node retrieval might cause misselection.
Tools follow a consistent verb_noun pattern (e.g., add_observations, create_entities) with minor deviations. 'get_current_time' uses 'get' instead of a more domain-specific verb, and 'open_nodes' uses 'open' which is less common in this context, but overall the naming is readable and mostly predictable.
With 10 tools, the count is well-scoped for managing a knowledge graph, covering creation, deletion, reading, and search operations. Each tool earns its place by addressing specific aspects of entity, relation, and observation handling, without feeling excessive or insufficient.
The tool set provides good coverage for knowledge graph CRUD operations, including create, read, and delete for entities, relations, and observations. A minor gap is the lack of update tools (e.g., update_entities or update_relations), which agents might need to work around by deleting and recreating, but core workflows are supported.
Maintenance
Related MCP Connectors
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
An MCP memory server. One memory your agents share — across models, devices and apps.
Personal knowledge graph as an AI memory layer over MCP - read, save, and link your memories.
Persistent, portable memory for AI assistants — your private memory graph, from any MCP client.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn advanced MCP server providing RAG-enabled memory through a knowledge graph with vector search capabilities, enabling intelligent information storage, semantic retrieval, and document processing.41 npm47MIT
- FlicenseNot gradedqualityDmaintenanceAn MCP server that implements a heavily typed knowledge graph memory system with AI-powered entity and relation extraction, enabling structured knowledge storage and retrieval from unstructured text using predefined or custom ontologies.9-
- AlicenseAqualityCmaintenanceEnhanced MCP knowledge graph memory server with cloud persistence and semantic search, acting as a drop-in replacement for the standard memory server.10207 npmMIT
- FlicenseNot gradedqualityDmaintenanceMCP server that gives AI agents and teams persistent, shared memory using a knowledge graph with vector embeddings, automatic consolidation of related facts, and hybrid search.3-