Knowledge Graph Memory Server

Memory Custom : PouchDB 🧠

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

This repo was forked from https://github.com/BRO3886/mcp-memory-custom which was a great starting point, thanks again for fixing timestamps. This repo's goal was more to fix the issue with an ever increasing json file for context.

New Features ✨

1. PouchDB Integration 💾

The server now uses PouchDB for robust document-based storage
Why?: Better data consistency, built-in versioning, and improved performance for large datasets
Maintains file backup for compatibility

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

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

Getting Started 🚀

Prerequisites 🔧

Node.js (version 16 or higher)
PouchDB (automatically installed as a dependency)

Installing via Smithery 📦

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

npx -y @smithery/cli install @bneil/mcp-memory-pouchdb --client claude

Installation 🛠️

Clone the repository:
git clone git@github.com:bneil/mcp-memory-pouchdb.git cd mcp-memory-pouchdb
Install the dependencies:
npm install

Configuration ⚙️

The server requires two environment variables to be set:

MEMORY_FILE_PATH: The absolute path where the memory backup file will be stored
POUCHDB_PATH: The absolute path where the PouchDB database will be stored

Example configuration in your claude_desktop_config.json / .cursor/mcp.json:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/path/to/mcp-memory-pouchdb/dist/index.js"],
      "env": {
        "MEMORY_FILE_PATH": "/path/to/custom/memory.json",
        "POUCHDB_PATH": "/path/to/custom/pouchdb_directory",
        "DISABLE_MEMORY_FILE": "true"
      }
    }
  }
}

The server will fail to start if either environment variable is not set. 🚫

Optional environment variables:

POUCHDB_OPTIONS: JSON string of additional PouchDB configuration options
DISABLE_MEMORY_FILE: Set to "true" to disable saving to memory.json file (only use PouchDB for storage)

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-pouchdb/dist/index.js"],
      "env" : {
        "MEMORY_FILE_PATH":"/home/.../local_dbs/memory.json",
        "POUCHDB_PATH":"/home/.../local_dbs/pouchdb"
      }
    }
  }
}

System Prompt changes:

Follow these steps for each interaction:

0. Memory Initialization:
   - At startup, execute a read_graph function to initialize memory access
   - If memory is empty, create a default entity for the user with basic placeholder info
   - Run initialization sequence: read_graph → create_entities → read_graph

1. User Identification:
   - You should assume that you are interacting with default_user
   - If you have not identified default_user, proactively try to do so

2. 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"
   - Verify memory access is functioning properly

3. Memory Attention:
   - 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)

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

5. Error Recovery:
   - If memory retrieval fails, execute read_graph function immediately
   - Log any memory access failures for debugging
   - Continue the conversation with best available information

6. Memory Validation:
   - Periodically verify that memory access is functional by checking for core entities
   - If validation fails, attempt reconnection via read_graph

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

Running the Server Locally 💻

To start the Knowledge Graph Memory Server, run:

npm run build
node dist/index.js

The 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
Powered by PouchDB for robust data storage 💾

This server cannot be installed

security - not tested

license - permissive license

quality - not tested

How are these scores calculated?

local-only server

The server can only run on the client's local machine because it depends on local resources.

Enhances the MCP memory server by implementing PouchDB for robust document storage and enabling the creation and management of a knowledge graph that captures interactions via language models.

Related MCP Servers

MemoryMesh
CheMiguel23
-
security
A
license
-
quality
This project is based on the Knowledge Graph Memory Server from the MCP servers repository and retains its core functionality.
Last updated -
44
107
TypeScript
MIT License
Memory Custom
BRO3886
A
security
A
license
A
quality
A customized MCP memory server that enables creation and management of a knowledge graph with features like custom memory paths and timestamping for capturing interactions via language models.
Last updated -
11
2
JavaScript
MIT License
MCP DuckDB Knowledge Graph Memory Server
IzumiSy
A
security
A
license
A
quality
A memory server for Claude that stores and retrieves knowledge graph data in DuckDB, enhancing performance and query capabilities for conversations with persistent user information.
Last updated -
8
30
40
TypeScript
MIT License
MCP Neo4j Knowledge Graph Memory Server
JovanHsu
-
security
A
license
-
quality
Enhanced knowledge graph memory server for AI assistants that uses Neo4j as the backend storage engine, enabling powerful graph queries and efficient storage of user interaction information with full MCP protocol compatibility.
Last updated -
TypeScript
MIT License

View all related MCP servers