Agenten stärken
Installation vom Herausgeber. Kein PlugMCP-Endpunkt.
Host a copy with our keys and logs.
Noch kein paketiertes Release in der Registry. Folgen Sie der README des Repositorys.
Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden
Auf PlugMCP ausführen
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
StartenVom Herausgeber
Claude Code is brilliant—but it's a goldfish. Every session starts from zero.
The cost of context loss:
Give Claude Code a permanent memory — 100% local, zero config, graph-powered
"Claude Code starts every session with zero context. There is no memory of previous sessions, previous work, or accumulated understanding of the user's projects and preferences." — GitHub Issue #14227
Claude Graph Memory fixes this.
A 100% local knowledge graph that runs alongside Claude Code, automatically indexing your documentation and code structure. Claude queries this graph to understand your project deeply, and stores learnings that persist forever.
┌─────────────────────────────────────────────────────────────────┐
│ Your Project │
│ ├── docs/ ──────────────────┐ │
│ │ ├── architecture.md │ │
│ │ ├── decisions/ ▼ │
│ │ └── api-specs/ ┌─────────────────────────────┐ │
│ └── src/ │ NornicDB Graph │ │
│ ├── components/ ───── │ ┌─────┐ ┌──────────┐ │ │
│ ├── services/ │ │ Doc │───▶│Component │ │ │
│ └── utils/ │ └─────┘ └──────────┘ │ │
│ │ │ │ │ │
│ │ ▼ ▼ │ │
│ Claude Code ◀────────────────▶│ ┌──────┐ ┌────────┐ │ │
│ (queries & stores memories) │ │Memory│ │Function│ │ │
│ │ └──────┘ └────────┘ │ │
│ └─────────────────────────────┘ │
│ ↑ │
│ Never leaves your machine │
└─────────────────────────────────────────────────────────────────┘
Most local RAG tools use vector databases for semantic similarity. But codebases aren't about "similar text"—they're about relationships.
Graphs preserve the structure of your project, not just the text.
Knowledge graphs offer transparent reasoning paths—if Claude gives you a wrong answer based on project context, you can open the graph browser at localhost:7474 and see exactly which node fed the hallucination.
/docs folder/docs:ProjectName:Document)# Clone the repo
git clone https://github.com/amarodeabreu/claude-graph-memory.git
cd claude-graph-memory
# Run the installer
./install.sh
That's it! The installer will:
neo4j Python driverclaude-graph CLI command./verify.sh
After installation, restart Claude Code to load the MCP servers. Then navigate to any project with a /docs folder—it will auto-populate on session start.
Start a new session; Claude queries the graph for recent decisions and project context without you re-explaining anything.
MATCH (d:MyProject:Document)-[:DESCRIBES]->(c:Component {name: 'AuthService'})
RETURN d.path, d.title
One query returns all docs, decisions, and code touching authentication.
Store a memory node that persists across all future sessions—Claude will know about it tomorrow, next week, forever.
Open localhost:7474, inspect the graph, and see exactly which nodes Claude used to make its recommendation.
┌──────────────────────────────────────────────────────────────────┐
│ Claude Code │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Hooks (in ~/.claude/settings.json) │ │
│ │ ├─ SessionStart → Check graph, auto-populate if empty │ │
│ │ └─ PostToolUse → Incremental update on file edits │ │
│ └────────────────────────────────────────────────────────────┘ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ MCP Servers (in ~/.claude.json) │ │
│ │ ├─ neo4j-memory → Store/retrieve persistent memories │ │
│ │ └─ neo4j-cypher → Run Cypher queries against the graph │ │
│ └────────────────────────────────────────────────────────────┘ │
├──────────────────────────────────────────────────────────────────┤
│ NornicDB (Docker) │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Graph Schema │ │
│ │ ├─ (:ProjectName:Document) → Indexed documentation │ │
│ │ ├─ (:ProjectName:Decision) → ADRs and decisions │ │
│ │ ├─ (:ProjectName:Component) → Extracted components │ │
│ │ ├─ (:ProjectName:File) → Code files │ │
│ │ ├─ (:ProjectName:Function) → Functions and methods │ │
│ │ └─ (:ProjectName:Class) → Classes and structs │ │
│ └────────────────────────────────────────────────────────────┘ │
│ Ports: 7474 (Browser UI) | 7687 (Bolt Protocol) │
└──────────────────────────────────────────────────────────────────┘
Projects are automatically detected from the directory name and converted to PascalCase:
When you edit a file in Claude Code:
PostToolUse hook fires.md, .go, .ts, .tsx, .js, .jsx, or .py fileAfter installation, use claude-graph from any project directory:
# Show current graph statistics
claude-graph status
# Full re-index (docs + code)
claude-graph refresh
# Index only documentation
claude-graph populate-docs
# Index only code
claude-graph populate-code
# Remove nodes for deleted files
claude-graph prune
# List all indexed projects
claude-graph list-projects
# Delete a project from the graph
claude-graph drop-project OldProjectName
# Show help
claude-graph help
// Documentation
(:Document {path, title, type, headings, content, updated_at})
(:Decision {id, title, status, path, context, decision, consequences})
(:Component {name})
(:Concept {name})
// Code
(:File {path, language, package, updated_at})
(:Function {name, file})
(:Struct {name, file}) // Go
(:Interface {name, file}) // Go, TypeScript
(:Class {name, file}) // TypeScript, Python
(Document)-[:DESCRIBES]->(Component)
(Document)-[:MENTIONS]->(Concept)
(Document)-[:REFERENCES]->(Document)
(File)-[:CONTAINS]->(Function|Struct|Interface|Class)
// Find docs about a component
MATCH (d:MyProject:Document)-[:DESCRIBES]->(c:Component {name: 'AuthService'})
RETURN d.path, d.title
// What functions are in a file?
MATCH (f:MyProject:File {path: 'src/auth.ts'})-[:CONTAINS]->(fn:Function)
RETURN fn.name
// Find all decisions
MATCH (d:MyProject:Decision)
RETURN d.id, d.title, d.status
// Trace everything related to a component
MATCH (n)-[r]-(c:Component {name: 'PaymentService'})
RETURN n, r, c
~/.claude.json # MCP server config (modified)
~/.claude/settings.json # Global hooks (modified)
~/.claude/scripts/
├── neo4j-context.sh # Main CLI script
├── populate-doc-graph.py # Documentation indexer
└── populate-code-graph.go # Go code indexer
~/.claude-graph-memory/
└── docker-compose.yml # NornicDB container config
~/.local/bin/claude-graph # CLI symlink
# Check status
docker ps | grep nornicdb
# Start it
docker start nornicdb
# Or use docker-compose
cd ~/.claude-graph-memory && docker-compose up -d
# View logs
docker logs nornicdb
# Check if port is open
nc -z localhost 7687 && echo "OK" || echo "Not running"
# Restart the container
docker restart nornicdb
# Force a full refresh
claude-graph refresh
# Check for errors in the hook
~/.claude/scripts/neo4j-context.sh session-start
~/.claude.json has the neo4j-memory and neo4j-cypher entrieswhich uvx./uninstall.sh
./install.sh
No. Everything runs locally:
Minimal. The graph database is very efficient:
Currently designed for single-machine use. For multi-machine sync, you'd need to:
Yes! It only indexes local files. Nothing leaves your machine.
Works fine, but initial population may take a minute. Incremental updates are always fast.
Yes! See CONTRIBUTING.md for how to add language support.
CLAUDE.md loads everything into the context window every session—competing for precious tokens. Claude Graph Memory provides targeted retrieval: Claude queries only what's needed, when needed. Plus, graphs capture relationships that flat markdown can't express.
Vector databases excel at "find similar text." But for code, you often need structural queries: "what functions are in this file," "which decisions affect this component," "show me everything connected to AuthService." Graphs model these relationships explicitly; vectors can only approximate them.
Contributions are welcome! See CONTRIBUTING.md for guidelines.
MIT License - see LICENSE for details.
Give Claude Code a permanent memory — 100% local, zero config, graph-powered
Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
Claude Graph Memory läuft lokal über stdio.
Zuletzt geprüft: 2026-10-28. Give Claude Code a permanent memory — 100% local, zero config, graph-powered
