Memory Custom

by bro3886

3 stars

205 downloads

Not rated

GitHub

About

Provides a knowledge graph-based memory system for creating, managing, and querying structured information with features like custom file paths, timestamping, and advanced search capabilities.

Details

Author: bro3886
Repository: BRO3886/mcp-memory-custom
GitHub stars: 3
Downloads: 205
License: MIT License
Categories: Database, AI, Knowledge Base, Developer Tools, Design, File Management, Search, Frontend, Infrastructure
Tags: #visualization

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below
Plugin Name Memory Custom

Command (node, npx, python, etc.) node
Arguments
- Argument 1 /path/to/mcp-memory-custom/dist/index.js
Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/c",
                "node",
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/c",
                "node",
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/c",
                "node",
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/c",
                "node",
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/c",
                "node",
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

From the repository

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.

To install Knowledge Graph Memory Server for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install @BRO3886/mcp-memory-custom --client claude

`Get Current Time`

Retrieves the current timestamp.

`Set Memory File Path`

Specifies the path for the memory file to be used in the current project.

`Create Entities`

Creates new entities in the memory graph based on provided data.

`Create Relations`

Establishes relationships between existing entities in the memory graph.

`Add Observations`

Stores facts about entities as observations in the memory graph.

`Delete Entities`

Removes specified entities from the memory graph.

`Delete Observations`

Removes specified observations from the memory graph.

`Delete Relations`

Removes specified relations between entities in the memory graph.

`Read Graph`

Retrieves the current state of the memory graph.

`Search Nodes`

Searches for specific nodes within the memory graph.

`Open Nodes`

Opens and displays details about specific nodes in the memory graph.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "memory custom": {
            "cwd": "optional",
            "env": {},
            "args": [
                "/path/to/mcp-memory-custom/dist/index.js"
            ],
            "shell": false,
            "command": "node"
        }
    }
}

Linux

{
    "cwd": "optional",
    "env": [],
    "args": [
        "/path/to/mcp-memory-custom/dist/index.js"
    ],
    "shell": false,
    "command": "node"
}

Macos

{
    "cwd": "optional",
    "env": [],
    "args": [
        "/path/to/mcp-memory-custom/dist/index.js"
    ],
    "shell": false,
    "command": "node"
}

Windows

{
    "cwd": "optional",
    "env": [],
    "args": [
        "/c",
        "node",
        "/path/to/mcp-memory-custom/dist/index.js"
    ],
    "shell": false,
    "command": "cmd"
}

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).

- 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.

- 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.

To install Knowledge Graph Memory Server for Claude Desktop automatically viaSmithery:

npx -y @smithery/cli install @BRO3886/mcp-memory-custom --client claude

git clone git@github.com:BRO3886/mcp-memory-custom.git cd mcp-memory-custom

Before running the server, you can set theMEMORY_FILE_PATHenvironment variable to specify the path for the memory file. If not set, the server will default to usingmemory.jsonin the same directory as the script.

Add this to yourclaude_desktop_config.json/.cursor/mcp.jsonfile:

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

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).

To start the Knowledge Graph Memory Server, run:

The server will listen for requests via standard input/output.

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

- Inspired by the Memory server from Anthropic.

Enables memory for Claude using a knowledge graph with fuzzy semantic search and persistent storage.

Enables persistent memory for Claude using a local knowledge graph of entities, relations, and observations.

Provides searchable local storage for Claude conversation history, enabling context retrieval during sessions.

An MCP memory server that uses a DuckDB backend for persistent knowledge graph storage.

An MCP server for graph-based memory management, enabling AI to create, retrieve, and manage knowledge entities and their relationships.

MCP memory server with Hebbian learning — concept connections strengthen through co-activation and weaken through disuse.

Enables persistent knowledge storage for Claude using a knowledge graph with multiple database backends like PostgreSQL and SQLite.

Enables persistent memory for Claude using a knowledge graph stored in local JSON files.

A knowledge graph server that provides persistent, multi-context memory for AI models.

Enables project memory using a Kuzu-powered knowledge graph.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

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

Claude Desktop / Cursor

Linux

Macos

Windows

Install

More like this

Aws Kb Retrieval Server

Redis

Memory

Sqlite

PostgreSQL

Context 7

`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`