Claude Code Memory Server

A Neo4j-based MCP server providing persistent memory and contextual assistance for Claude Code.

View on GitHub →

Claude Code Memory Server

A Neo4j-based Model Context Protocol (MCP) server that provides intelligent memory capabilities for Claude Code, enabling persistent knowledge tracking, relationship mapping, and contextual development assistance.

Overview

This MCP server creates a sophisticated memory system that tracks Claude Code's activities, decisions, and learned patterns to provide contextual memory across sessions and projects. It uses Neo4j as a graph database to capture and analyze complex relationships between development concepts, solutions, and workflows.

Features

Core Memory Operations

  • Persistent Memory Storage - Store development tasks, solutions, and patterns
  • Intelligent Search - Find relevant memories by context, content, or relationships
  • Relationship Mapping - Track how different concepts, files, and solutions relate
  • Context Awareness - Project-specific and technology-specific memory retrieval

Advanced Intelligence

  • Pattern Recognition - Automatically identify reusable development patterns
  • Solution Effectiveness - Track and learn from successful approaches
  • Workflow Memory - Remember and suggest optimal development sequences
  • Error Prevention - Learn from past mistakes to prevent similar issues

Development Integration

  • Task Execution Tracking - Monitor what Claude Code does and how
  • Code Pattern Analysis - Identify and store successful code patterns
  • Project Context Memory - Understand codebase conventions and dependencies
  • Collaborative Learning - Share knowledge across development sessions

Architecture

Memory Types

  • Task - Development tasks and their execution patterns
  • CodePattern - Reusable code solutions and architectural decisions
  • Problem - Issues encountered and their context
  • Solution - How problems were resolved and their effectiveness
  • Project - Codebase context and project-specific knowledge
  • Technology - Framework, language, and tool-specific knowledge

Relationship Types

The system tracks seven categories of relationships:

  1. Causal - CAUSES, TRIGGERS, LEADS_TO, PREVENTS, BREAKS
  2. Solution - SOLVES, ADDRESSES, ALTERNATIVE_TO, IMPROVES, REPLACES
  3. Context - OCCURS_IN, APPLIES_TO, WORKS_WITH, REQUIRES, USED_IN
  4. Learning - BUILDS_ON, CONTRADICTS, CONFIRMS, GENERALIZES, SPECIALIZES
  5. Similarity - SIMILAR_TO, VARIANT_OF, RELATED_TO, ANALOGY_TO, OPPOSITE_OF
  6. Workflow - FOLLOWS, DEPENDS_ON, ENABLES, BLOCKS, PARALLEL_TO
  7. Quality - EFFECTIVE_FOR, INEFFECTIVE_FOR, PREFERRED_OVER, DEPRECATED_BY, VALIDATED_BY

Installation

Prerequisites

  • Python 3.10 or higher
  • Neo4j database (local or cloud)
  • Claude Code with MCP support

Setup

  1. Clone the repository:
git clone https://github.com/viralvoodoo/claude-code-memory.git
cd claude-code-memory
  1. Install dependencies:
pip install -e .
  1. Set up Neo4j connection:
cp .env.example .env
# Edit .env with your Neo4j credentials
  1. Initialize the database schema:
python -m claude_memory.setup

Configuration

Environment Variables

  • NEO4J_URI - Neo4j database URI (default: bolt://localhost:7687)
  • NEO4J_USER - Database username (default: neo4j)
  • NEO4J_PASSWORD - Database password
  • MEMORY_LOG_LEVEL - Logging level (default: INFO)

Claude Code Integration

Add to your Claude Code MCP configuration:

{
  "mcpServers": {
    "claude-memory": {
      "command": "python",
      "args": ["-m", "claude_memory.server"],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USER": "neo4j",
        "NEO4J_PASSWORD": "your-password"
      }
    }
  }
}

Usage

Available MCP Tools

Core Memory Operations

  • store_memory - Store new development memories with context
  • get_memory - Retrieve specific memory by ID with relationships
  • search_memories - Find memories by content, context, or relationships
  • update_memory - Modify existing memory content
  • delete_memory - Remove memory and cleanup relationships

Relationship Management

  • create_relationship - Link memories with specific relationship types
  • get_related_memories - Find memories connected to a specific memory
  • analyze_relationships - Discover relationship patterns in memory graph

Development Intelligence

  • analyze_codebase - Scan project and create contextual memory graph
  • track_task_execution - Record development workflow and patterns
  • suggest_similar_solutions - Find analogous past solutions
  • predict_solution_effectiveness - Estimate success probability of approaches

Advanced Analytics

  • get_memory_graph - Visualize knowledge network and relationships
  • find_memory_paths - Discover connection chains between concepts
  • memory_effectiveness - Track and analyze solution success rates

Development

Project Structure

claude-code-memory/
├── src/claude_memory/          # Main source code
│   ├── __init__.py
│   ├── server.py              # MCP server implementation
│   ├── models.py              # Data models and schemas
│   ├── database.py            # Neo4j database operations
│   ├── memory_store.py        # Core memory logic
│   ├── relationships.py       # Relationship management
│   ├── search.py              # Search and retrieval
│   └── intelligence.py        # Pattern recognition and analytics
├── tests/                     # Test suite
├── docs/                      # Documentation
├── scripts/                   # Utility scripts
└── pyproject.toml            # Project configuration

Development Setup

# Install development dependencies
pip install -e ".[dev]"

# Install pre-commit hooks
pre-commit install

# Run tests
pytest

# Format code
black src/ tests/
ruff --fix src/ tests/

# Type checking
mypy src/

Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Workflow

  1. Check existing GitHub Issues
  2. Fork the repository and create a feature branch
  3. Make changes following our coding standards
  4. Add tests for new functionality
  5. Submit a pull request with a clear description

License

This project is licensed under the MIT License - see the LICENSE file for details.

Roadmap

Phase 1: Foundation (Current)

  • ✅ Project setup and basic MCP server
  • 🔄 Core memory operations (CRUD)
  • ⏳ Basic relationship management

Phase 2: Intelligence

  • ⏳ Advanced relationship system
  • ⏳ Pattern recognition
  • ⏳ Context awareness

Phase 3: Integration

  • ⏳ Claude Code workflow integration
  • ⏳ Automatic memory capture
  • ⏳ Proactive suggestions

Phase 4: Analytics

  • ⏳ Memory effectiveness tracking
  • ⏳ Knowledge graph visualization
  • ⏳ Performance optimization

Support

Acknowledgments

Related Servers