Knowledge Graph: A Persistent Knowledge Graph Memory Layer Built for Claude Code

This article introduces a zero-dependency knowledge graph-driven memory system specifically designed for Claude Code. Through event tracking, collaborative change analysis, and evidence-driven rule generation, this system addresses the statelessness pain point of AI coding assistants across sessions, achieves context continuity, and allows wisdom to accumulate from each interaction.

AI coding assistants like Claude Code and Cursor are powerful, but they have a fundamental issue—statelessness. Each new session starts from scratch, losing all previous code explorations, error lessons, and architectural decisions. The Knowledge Graph project was born to solve this pain point by building a persistent, evidence-driven memory layer.

Project Overview: Knowledge Graph is a knowledge graph-driven memory system designed specifically for Claude Code. It only depends on jq, implemented with bash scripts and git. It tracks file operations via hooks, builds distributed CLAUDE.md knowledge nodes, and automatically injects context. Core Architecture: Divided into three layers:

1. Event Tracking Layer: Captures read/write/edit operations and records them in local logs;
2. Inference Analysis Layer: A pure bash engine that mines collaborative change patterns, etc., with zero LLM token consumption;
3. Knowledge Generation Layer: LLM generates concise CLAUDE.md rules based on analysis results (≤20 lines per module).

v1.2 Zero Interruption Experience: Eliminates mandatory updates during coding; only saves snapshots (touched modules, modified content, errors, commits) at the end of the session. The next session injects the snapshot to restore state, and the clear command does not lose context. Session Boundary Management Hooks: Implements seamless state management through multiple hooks, such as SessionStart (inject snapshot), Stop (save snapshot and rotate events), PreCompact (inform compressor to retain modules), etc.

Intelligent Prediction: Based on historical collaborative change analysis, preloads relevant module taboo rules when accessing a module for the first time, with a 300-second TTL cache to optimize performance. Evidence-Driven Rules: Each rule can be traced back to specific commits/errors. CLAUDE.md follows a strict format (Prohibitions/When Changing/Conventions), and @ references establish a dependency graph. Context Persistence: Knowledge indexes, module CLAUDE.md, working states, etc., are retained through mechanisms like snapshots and @include after clear/compact operations.

Performance Optimization: v1.2 introduces event rotation (truncated to 300 lines), corrupted line fault tolerance, bounded prediction (latest 300 events), N+1 elimination, etc. Token Control: Knowledge index ~300-500 tokens (always loaded), work snapshot ~200-400 tokens (session start), prediction rules ~100 tokens per module (first access), total baseline proportion <0.5% of the 200K context. MCP Tool Integration: Provides four tools: kg_status (health report), kg_query (keyword search), kg_predict (related module prediction), kg_cochange (collaborative change directory pairs).

Practical Significance: Addresses core pain points such as long-term project memory, error prevention, team collaboration, onboarding for new members, and architectural evolution. Comparison with Similar Solutions: Compared to mcp-knowledge-graph, Memento, and Caveman, this system has obvious advantages in persistent memory, reasoning ability, zero dependency, zero interruption, etc. Conclusion: This system represents a new AI-assisted programming paradigm—not a larger context window, but better management of limited context, bringing qualitative efficiency improvements to complex projects.