memory-bankLABSCO SUMMARY
A graph, not a note pile — and the destructive parts snapshot first.
Storing decisions and components as nodes with real edges is what makes analyze useful: PageRank over a component graph tells you what matters, and connected-component detection tells you what has drifted apart. Optimisation is the risky operation, so it takes a snapshot before it runs and rollback restores the previous state; the conservative strategy caps deletions and uses a six-month staleness threshold.
What it is
A memory bank stored in a KùzuDB graph database. Entities and relationships are keyed so that each repository and branch gets its own view of a shared bank, and graph algorithms run over the result.
What you get
- memory-bank — initialise and manage the bank's metadata for a repository and branch
- entity — create, update, delete and retrieve every entity type: components, decisions, rules, files and tags
- associate — create relationships between entities
- query — one search across contexts, entities, relationships, dependencies, governance, history and tags
- search — full-text search over all entity types, backed by KuzuDB's FTS
- introspect — explore the graph schema and metadata
- context — manage the working context of a session
- analyze — run graph algorithms over a projected graph: PageRank, K-Core, Louvain and shortest path
- detect — find strongly and weakly connected components
- bulk-import — load entities in bulk
- delete — remove entities with dependency validation, including bulk deletes
- memory-optimizer — analyse the graph, preview an optimisation as a dry run, execute it with an automatic snapshot, list snapshots and roll back
Requirements
Node.js with the project cloned and built. Configuration goes in a .env file: DB_FILENAME for the graph file, HTTP_STREAM_PORT and HOST for the HTTP stream server. The memory-optimizer needs a reasoning model — OPENAI_API_KEY or ANTHROPIC_API_KEY — and is the only part that does; everything else runs locally.
Setup effort
Build from source — git clone https://github.com/Jakedismo/KuzuMem-MCP.git
USE CASES
01
Starting a memory bank for a repository
Initialise the bank for that repo and branch, then load the existing components and decisions in bulk.
02
Recording why something is the way it is
Create the decision as an entity and link it to the components it constrains.
03
Working out what a change touches
Query the dependency direction from one component and read what sits downstream.
04
Finding the load-bearing parts of a codebase
Project a component graph and rank it, then look for clusters that have separated.
05
Clearing out memory that has gone stale
Analyse the graph, preview the optimisation as a dry run, then run it with a snapshot you can roll back to.
06
Finding something you half remember
Run a full-text search across every entity type instead of guessing the entity id.
12 tools
Listed in project docs. Your client may show a different list.
entityintrospectcontextqueryassociateanalyzedetectbulk-importsearchdeletememory-optimizerBEFORE YOU INSTALL
What to know first
Tools you get
12 tools named in the project's documentation.
Optional
- OPENAI_API_KEY in your environment
- ANTHROPIC_API_KEY in your environment
INSTALLATION
Connect your client
Server setup
Build from source
TERMINAL
# Clone the repository
git clone https://github.com/Jakedismo/KuzuMem-MCP.git
cd KuzuMem-MCP
# Install dependencies
npm install
# Build the project
npm run buildConfiguration file
JSON
{
"mcpServers": {
"KuzuMem-MCP": {
"command": "npx",
"args": [
"-y",
"ts-node",
"<YOUR_PATH_TO_KUZU_MEM_MCP>/src/mcp-stdio-server.ts"
],
"env": {
"PORT": "3000",
"HOST": "localhost",
"DB_FILENAME": "memory-bank.kuzu",
"HTTP_STREAM_PORT": "3001"
}
}
}
}OPENAI_API_KEY or ANTHROPIC_API_KEY is needed only for the memory-optimizer tool; put it in the .env file in your clone.
