Personal Memory MCP Server

Tired of AI conversations that restart from scratch every time? This system enables AI to truly remember and understand you. Your personality, preferences, relationships, and important experiences are naturally remembered by AI, allowing for deep and personal communication like a longtime friend or partner in every conversation. Go beyond simple Q&A and create a genuine AI experience based on real relationships and understanding.

Features

• Entity-based data organization (Person, Company, Project, etc.)
• Observation tracking with importance scoring
• Relationship mapping between entities
• Search and summary capabilities
• TypeScript implementation with SQLite database
• 🎨 Web Dashboard: Modern React-based UI for managing memory data
• 📊 Visualizations: Charts and graphs for memory insights
• 🔍 Advanced Search: Filter by importance, type, and relationships

Installation

📦 From npm (Recommended)

# Install globally for easy access
npm install -g personal-memory-mcp

What happens after installation:

• ✅ Fresh SQLite database created automatically in ./data/memory.db
• ✅ Sample entities and observations added to get you started
• ✅ Both MCP server and dashboard binaries available globally
• ✅ Ready to use immediately!

Quick Start:

# Start MCP server
personal-memory-mcp

# Start web dashboard (in another terminal)
personal-memory-dashboard

🛠️ From Source (Development)

1. Install the MCP Server

# Clone repository
cd my-memory-mcp

# Install dependencies
npm install

# Build
npm run build

# Start server
npm start

2. Launch Web Dashboard (Optional)

For a visual interface to manage your memory data:

# Quick start (Windows)
./start-dashboard.bat

# Quick start (Linux/Mac)
./start-dashboard.sh

# Or manually:
npm run build:dashboard
DASHBOARD_PORT=3001 npm run dashboard

Then open http://localhost:3001 in your browser.

3. Configure Claude Desktop

Add this configuration to your Claude Desktop config file:

Windows: %APPDATA%\Claude\claude_desktop_config.json macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "my-memory": {
      "command": "node",
      "args": ["path/to/my-memory-mcp/dist/index.js"],
      "env": {
        "DATABASE_PATH": "path/to/my-memory-mcp/data/my-memory.sqlite"
      }
    }
  }
}

3. Configure Cursor AI

Add this to your Cursor AI settings:

1. Open Cursor AI Settings
2. Go to "Tools & Intergrations" → "MCP Tools"
3. Add new MCP server:

{
  "mcpServers": {
    "my-memory": {
      "command": "node",
      "args": ["path/to/my-memory-mcp/dist/index.js"],
      "env": {
        "DATABASE_PATH": "path/to/my-memory-mcp/data/my-memory.sqlite"
      }
    }
  }
}

Note: Replace path/to/my-memory-mcp with the actual path to your installation directory.

Development

# Development mode with auto-restart
npm run dev

# Type checking
npm run type-check

# Clean build
npm run clean

API Tools

my-memory:create

Create entities, observations, or relations.

Parameters:

• type: "entity" | "observation" | "relation"
• entityType: Entity type (for entities)
• name: Entity name (for entities)
• entityId: Target entity ID (for observations)
• value: Observation content (for observations)
• sourceEntityId: Source entity ID (for relations)
• targetEntityId: Target entity ID (for relations)
• importanceScore: Importance score (0-100)
• notes: Additional notes
• properties: Relation properties (JSON object)

my-memory:get

Retrieve entities, observations, or relations.

Parameters:

• type: "entity" | "observation" | "relation"
• entityType: Filter by entity type
• entityId: Filter by specific entity
• sourceEntityId: Filter by source entity (relations)
• minImportance: Minimum importance score
• includeDetails: Include detailed information

my-memory:search

Search and summarize memory data.

Parameters:

• mode: "summary" | "importance"
• entityId: Entity to summarize (summary mode)
• minScore: Minimum importance score (importance mode)
• type: Filter by data type
• includeDetails: Include detailed information

my-memory:update

Update existing entities, observations, or relations.

Parameters:

• type: "entity" | "observation" | "relation"
• id: ID of item to update
• data: Updated data fields

my-memory:delete

Delete entities, observations, or relations.

Parameters:

• type: "entity" | "observation" | "relation"
• id: ID of item to delete
• entityId: Delete all items for specific entity
• cascade: Delete related data
• minImportance: Minimum importance for deletion
• maxImportance: Maximum importance for deletion

Data Structure

Entity

• Represents people, companies, projects, concepts, etc.
• Has type, name, and importance score
• Can have multiple observations and relations

Observation

• Specific information about an entity
• Includes type, value, importance score, and notes
• Timestamped for tracking changes

Relation

• Connection between two entities
• Has type and optional properties
• Supports complex relationship modeling

Usage Examples

// Create a person entity
my-memory:create({
  type: "entity",
  entityType: "Person", 
  name: "John Doe",
  importanceScore: 80
})

// Add observation about the person
my-memory:create({
  type: "observation",
  entityId: "entity_id",
  value: "Prefers direct communication",
  importanceScore: 85,
  notes: "Important for work interactions"
})

// Create relationship
my-memory:create({
  type: "relation",
  sourceEntityId: "person_id",
  targetEntityId: "company_id", 
  properties: { role: "developer", startDate: "2025-01-01" }
})

// Search by importance
my-memory:search({
  mode: "importance",
  minScore: 80,
  includeDetails: true
})

// Get entity summary
my-memory:search({
  mode: "summary",
  entityId: "entity_id"
})

Recommended User Preferences

For optimal use with AI assistants, add this configuration to your user preferences:

0. Session initialization (execute only once at session start):
   - Query relationships with importance score 80+ using includeDetails=true from my-memory MCP
   - Additionally query observations with importance score 80+ for relevant entities
   - Do not brief the retrieved personal memories

1. Continuous operation during conversations:
   - Record new personal information in my-memory MCP when discovered
   - Judge importance score (0-100 points) for all responses
   - Base judgments only on existing memories without repeated queries

2. Personal information collection (personal information only):
   - Basic identity (age, gender, location, occupation, education, health status, etc.)
   - Behavioral patterns (interests, habits, hobbies, personality traits, etc.)
   - Preferences (communication style, preferred language, style, values, etc.)
   - Long-term goals (life goals, long-term plans, personal aspirations, etc.)
   - Relationships (family, friends, romantic partners, colleagues, etc.)

3. my-memory MCP memory updates:
   - Entity creation (with importance scores): Important people, organizations, places, concepts
   - Relationship connections: Establish relations with existing entities
   - Observation storage: Record personal characteristics and facts as observations

4. What NOT to record in my-memory MCP:
   - Specific work details (coding specifics, particular task progress, etc.)
   - Temporary work memory (today's tasks, temporary notes, etc.)
   - Technical details (configuration values, code snippets, error messages, etc.)

5. Additional operational principles for my-memory MCP:
   - Set importance scores based on personal significance and long-term relevance
   - Record relationship information with high importance
   - Carefully record personal tendencies and values
   - Record work-related information only at company name, position, colleague name level

MCP Client Configuration

Add this to your MCP client configuration file (e.g., ~/.cursor/mcp.json):

For Global npm Installation

{
  "mcpServers": {
    "my-memory": {
      "command": "personal-memory-mcp"
    }
  }
}

For Local/Source Installation

{
  "mcpServers": {
    "my-memory": {
      "command": "node",
      "args": ["path/to/my-memory-mcp/dist/index.js"]
    }
  }
}

Publishing to npm

To publish this package to npm:

1. Update package details in package.json:

   • Change name to your desired package name
   • Update author, repository, homepage, and bugs URLs
   • Increment version for updates

2. Build the package:

   npm run build

3. Test locally (optional):

   npm pack
   npm install -g ./my-memory-mcp-1.0.0.tgz

4. Publish to npm:

   npm login
   npm publish

5. Install from npm:

   npm install -g your-package-name

License

MIT License