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

2. Install dependencies:

pip install -e .

3. Set up Neo4j connection:

cp .env.example .env
# Edit .env with your Neo4j credentials

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

• GitHub Issues - Bug reports and feature requests
• Discussions - Questions and community support
• Documentation - Detailed guides and API reference

Acknowledgments

• Model Context Protocol - Protocol specification and examples
• Neo4j - Graph database platform
• Claude Code - AI-powered development environment