MCP Automem

AutoMem MCP is an MCP client tool that provides persistent memory for AI assistants. By connecting to the AutoMem graph - vector memory service, MCP - compatible AI platforms such as Claude, Cursor, and GitHub Copilot can remember users' decisions, coding styles, and preferences across sessions and devices, achieving perfect memory and personalized interaction.

Knowledge management and memory Developer tools #AI memory #Cross - platform #Graph - vector #Persistent .TypeScript

rating : 2.5 points

downloads : 5.7K

update time : 2026-03-12

Open Site

What is AutoMem MCP?

AutoMem MCP is a Model Context Protocol server that connects your AI assistant to an advanced memory system. Traditional AI conversations start anew each time, while AutoMem enables AI to remember everything about you: coding style, decision - making logic, and project preferences, maintaining consistency across all conversations. It's like a long - term memory brain for AI, storing and retrieving information through a graph - vector architecture, allowing your AI assistant to truly understand your work habits and thinking patterns.

How to use AutoMem MCP?

Using AutoMem is very simple: 1. Deploy the AutoMem memory service (locally or in the cloud) 2. Install the MCP client in your AI tool 3. Configure the connection parameters 4. Start the conversation, and the AI will automatically remember and learn It supports all MCP - compatible platforms such as Claude Desktop, Cursor IDE, Claude Code, ChatGPT, and GitHub Copilot.

Use cases

• Software development: Let AI remember your coding specifications and project architecture • Decision support: Provide personalized suggestions based on historical decisions • Team collaboration: Share team preferences and best practices • Learning assistant: Track learning progress and knowledge acquisition over the long term • Personalized AI: Create an intelligent assistant that truly understands your habits

Main features

Persistent memory

AI memory is permanently saved and synchronized across sessions and devices. There's no need to repeatedly explain the same concepts, and the AI always remembers your preferences and decisions.

Graph - vector architecture

Combining the relational modeling of graph databases and the semantic understanding of vector search, it implements 11 types of memory relationships, supporting multi - hop reasoning and context - aware retrieval.

Cross - platform support

Supports all major AI platforms: Claude Desktop, Cursor IDE, Claude Code, ChatGPT, GitHub Copilot, OpenAI Codex, etc.

Multi - hop reasoning

Supports reasoning for complex questions, such as 'What is the occupation of Amanda's sister?', and finds relevant memory chains through entity expansion.

Context - aware coding

Based on the current programming language, project type, and file content, it intelligently recalls the most relevant coding patterns and best practices.

Remote MCP support

Supports remote connection via HTTP/SSE, enabling ChatGPT, Claude Web, mobile devices, etc. to use the AutoMem memory system.

Advantages

True long - term memory: Memory is permanently saved without session limitations

Cross - platform consistency: Use the same memory across all AI tools

Personalized experience: AI learns your unique style and preferences

Research - verified: Based on the latest memory research such as HippoRAG 2

Open - source and self - hosted: Full control over data at low cost

Easy to deploy: Supports multiple deployment methods such as local, Railway, and Docker

Limitations

Requires additional deployment of the memory service (but simple deployment options are provided)

Initial setup requires technical configuration (a wizard is provided to simplify the process)

Memory quality depends on usage frequency and patterns

Requires AI platforms to support the MCP protocol

How to use

Deploy the memory service

Choose the deployment method: local development (free) or Railway cloud (recommended for production environments). Local deployment only requires running make dev, and cloud deployment can be done with one click.

Install the MCP client

Choose the installation method according to your AI platform. For Claude Desktop, you can download the.mcpb file for installation, and for other platforms, use the npx command.

Configure the connection

Set the AutoMem service endpoint (http://localhost:8001 for local) and the API key (required for cloud). The wizard will automatically generate the configuration.

Start using

In AI conversations, memories will be automatically stored and recalled. You can also manually call memory operations.

Usage examples

Learn personal coding style

AI learns your coding preferences through multiple code reviews, such as error - handling patterns, naming conventions, and code structures.

Technical decision support

When facing technical selections, AI provides suggestions that match your thinking pattern based on your past decision records and reasons.

Project context memory

AI remembers the project's architectural decisions, technical debts, team agreements, etc., providing consistent context - aware assistance.

Multi - hop reasoning query

Answer complex questions through entity relationship chains, demonstrating the powerful reasoning ability of graph memory.

Frequently Asked Questions

Is AutoMem MCP free?

Is my data secure?

Which AI platforms are supported?

Do I need programming knowledge to set it up?

How much storage space does the memory take up?

How can I delete or modify memories?

Does it support team collaboration?

What if the memory service goes down?

Related resources

GitHub repository

MCP client source code and documentation

AutoMem service repository

Memory backend service, including deployment guide

Installation guide

Detailed platform installation and configuration instructions

Discord community

Get help, share feedback, and join the community

NPM package

MCP client NPM package page

Railway deployment

One - click cloud deployment of the memory service

Research paper

HippoRAG 2 paper (basis of the graph - vector memory architecture)

🚀 AutoMem MCP: Give Your AI Perfect Memory

One command. Infinite memory. Perfect recall across all your AI tools.

🚀 Quick Start

1. Set Up AutoMem Service

You need a running AutoMem service (the memory backend). Choose one:

Option A: Local Development (fastest, free)

git clone https://github.com/verygoodplugins/automem.git
cd automem
make dev

Service runs at http://localhost:8001 - perfect for single-machine use.

Option B: Railway Cloud (recommended for production) One-click deploy with $5 free credits. Typical cost: ~$0.50 - 1/month after trial.

👉 AutoMem Service Installation Guide - Complete setup instructions for local, Railway, Docker, and production deployments.

2. Install MCP Client

Claude Desktop - One-Click Install

Download and double-click to install AutoMem in Claude Desktop: ⬇️ Download AutoMem for Claude Desktop (.mcpb)

After installing:

Claude Desktop will prompt you for your AutoMem Endpoint (http://127.0.0.1:8001 for local)
Optionally enter your API Key (required for Railway, skip for local)
Click Enable

That's it! Claude now has persistent memory.

Other Platforms

Connect your AI tools to the AutoMem service you just started.

# Guided setup - creates .env and prints config for your AI platform
npx @verygoodplugins/mcp-automem setup

When prompted:

AutoMem Endpoint: http://localhost:8001 (or your Railway URL if deployed)
API Key: Leave blank for local development (or paste your token for Railway)

The wizard will:

✅ Save your endpoint and API key to .env
✅ Generate config snippets for Claude Desktop/Cursor/Code
✅ Validate connection to your AutoMem service

3. Platform-Specific Setup

For Claude Desktop:

# Setup prints config snippet - just paste into claude_desktop_config.json
npx @verygoodplugins/mcp-automem setup

For Cursor IDE:

# Or use CLI to install automem.mdc rule file
npx @verygoodplugins/mcp-automem cursor

Note: After one-click install, configure your AUTOMEM_ENDPOINT in ~/.cursor/mcp.json or Claude Desktop config

For Claude Code:

Option A: Plugin (Recommended)

# In Claude Code, install the plugin:
/plugin marketplace add verygoodplugins/mcp-automem
/plugin install automem@verygoodplugins-mcp-automem

Only one Claude Code plugin ships in this repo: plugins/automem with the marketplace catalog at .claude-plugin/marketplace.json.

Option B: CLI Setup

# Installs SessionStart hook and MCP permissions
npx @verygoodplugins/mcp-automem claude-code

For OpenAI Codex:

# Add to your Codex MCP configuration
npx @verygoodplugins/mcp-automem config --format=json

# Optional: add memory-first rules to this repo
npx @verygoodplugins/mcp-automem codex

👉 Full Installation Guide for detailed MCP client and platform-specific setup

✨ Features

Core Memory Operations

store_memory - Save memories with content, tags, importance, metadata
recall_memory - Hybrid search with graph expansion and context awareness:
- Basic search: query, multi-query, tags, time filters
- Graph expansion: entity expansion (multi-hop reasoning), relation following
- Expansion filtering: expand_min_importance and expand_min_strength to reduce noise in expanded results
- Context hints: language, active file, priority types/tags
associate_memories - Create relationships (11 public authorable types; recall results may also include read-only system relations)
update_memory - Modify existing memories
delete_memory - Remove memories
check_database_health - Monitor service status

Advanced Recall (v0.8.0+)

Multi-hop Reasoning - Answer complex questions like "What is Amanda's sister's career?"

mcp__memory__recall_memory({
  query: "What is Amanda's sister's career?",
  expand_entities: true, // Finds "Amanda's sister is Rachel" → memories about Rachel
});

Context-Aware Coding - Recall prioritizes language and style preferences

mcp__memory__recall_memory({
  query: "error handling patterns",
  language: "typescript",
  context_types: ["Style", "Pattern"],
});

Platform Integrations

Cursor IDE

✅ Memory-first rule file (automem.mdc in .cursor/rules/)
✅ Automatic memory recall at conversation start
✅ Auto-detects project context (package.json, git remote)
✅ Global user rules option for all projects
✅ Simple setup via CLI or one-click install

Claude Code

✅ MCP permissions for memory tools
✅ Memory rules in CLAUDE.md guide Claude's memory usage
✅ Simple setup - just permissions, Claude decides what to store

Claude Desktop

✅ Direct MCP integration
✅ Manual and automated workflows
✅ Full memory API access

📦 Installation

npx @verygoodplugins/mcp-automem setup

Your AI assistant now remembers everything. Forever. Across every conversation.

Works with Claude Desktop, Cursor IDE, Claude Code, GitHub Copilot (coding agent), ChatGPT, ElevenLabs, OpenAI Codex - any MCP-compatible AI platform.

💻 Usage Examples

Your AI Learns Your Code Style

// After 1 week, your AI writes EXACTLY like you
// ✅ It knows you prefer early returns
// ✅ It uses your specific variable naming
// ✅ It matches your comment style
// ✅ It follows YOUR patterns, not generic best practices

Decisions That Feel Like Yours

User: "Should we use Redis for this?"

Without AutoMem:
"Consider RabbitMQ, Kafka, or AWS SQS based on your needs..."

With AutoMem:
"Based on your pattern of preferring boring technology that works,
and your positive experience with Redis in Project X (March 2024),
yes. You specifically value operational simplicity over feature
richness - Redis fits perfectly."

📚 Documentation

MCP Client & Integrations (this repo)

📦 Installation Guide - MCP client setup for all platforms
🌐 Remote MCP via SSE - Connect ChatGPT, Claude Web/Mobile, ElevenLabs
🎯 Cursor Setup - IDE integration with rules
🤖 Claude Code Setup - Memory rules integration
🚀 OpenAI Codex Setup - Codex CLI/IDE/Cloud integration
📖 MCP Tools Reference - All memory operations

AutoMem Service (separate repo)

🏗️ AutoMem Service - Backend repository
🚀 Service Installation - Local, Railway, Docker deployment
⚙️ API Documentation - REST API reference

🔧 Technical Details

The Problem We Solve

Every AI conversation starts from zero. Claude forgets your coding style. Cursor can't learn your patterns. Your assistant doesn't remember yesterday's decisions.

Until now.

AutoMem MCP connects your AI to persistent memory powered by AutoMem - a graph-vector memory service.

What You Get

🧠 Persistent Memory Across Sessions

AI remembers decisions, patterns, and context forever
Works across all MCP platforms - Claude Desktop, Cursor, Claude Code
Cross-device sync - same memory on Mac, Windows, Linux

🏆 Graph-Vector Architecture

11 public authorable relationship types between memories (recall results may also include read-only system/internal relations that are not valid associate_memories inputs)
Research-validated approach (HippoRAG 2: 7% better associative memory)
Sub-second retrieval even with millions of memories

🚀 Works Everywhere You Code

Platform	Support	Setup Time
Claude Desktop	✅ Full	30 seconds
Cursor IDE	✅ Full	30 seconds
Claude Code	✅ Full	30 seconds
GitHub Copilot	✅ Full	2 minutes
OpenAI Codex	✅ Full	30 seconds
Any MCP client	✅ Full	30 seconds

Architecture

┌─────────────────────────────────────────────┐
│         Your AI Platforms                   │
│  Claude Desktop │ Cursor │ Claude Code      │
└──────────────┬──────────────────────────────┘
               │ MCP Protocol
               ▼
┌──────────────────────────────────────────────┐
│   @verygoodplugins/mcp-automem (this repo)  │
│   • Translates MCP calls → AutoMem API      │
│   • Platform integrations & rules           │
│   • Handles authentication                   │
└──────────────┬───────────────────────────────┘
               │ HTTP API
               ▼
┌──────────────────────────────────────────────┐
│        AutoMem Service (separate repo)       │
│        github.com/verygoodplugins/automem    │
│   ┌────────────┐      ┌────────────┐        │
│   │  FalkorDB  │      │   Qdrant   │        │
│   │  (Graph)   │      │ (Vectors)  │        │
│   └────────────┘      └────────────┘        │
└──────────────────────────────────────────────┘

This repo (mcp-automem):

MCP client that connects AI platforms to AutoMem
Platform-specific integrations (Cursor rules, Claude Code hooks, etc.)
Setup wizards and configuration tools

AutoMem service:

Backend memory service with graph + vector storage
Deployment guides (local, Railway, Docker, production)
API server with FalkorDB + Qdrant

New: Remote MCP via HTTP

You can now connect AutoMem to platforms that support remote MCP via Streamable HTTP (recommended) or SSE transport via an optional sidecar service (deployable to Railway or any Docker host).

ChatGPT (Developer Mode custom connectors)
Claude.ai (web) and Claude Mobile (iOS/Android)
ElevenLabs Agents Platform

Quick connect URLs (after deploying the sidecar):

Streamable HTTP (recommended): https://<your-mcp-domain>/mcp?api_token=<AUTOMEM_API_TOKEN>
SSE (legacy): https://<your-mcp-domain>/mcp/sse?api_token=<AUTOMEM_API_TOKEN>
ElevenLabs: https://<your-mcp-domain>/mcp with header Authorization: Bearer <AUTOMEM_API_TOKEN>

See the Installation Guide for complete steps and deployment options.

Remote MCP Platforms in Action

ChatGPT Developer Mode: Add your MCP endpoint as a custom connector

ChatGPT using AutoMem memories via remote MCP

Claude.ai website connected to AutoMem via remote MCP

Claude Mobile (iOS) connected to AutoMem via remote MCP

What Happens Next

Timeline	What Your AI Learns
Hour 1	Starts capturing your patterns
Day 1	Learns your decision factors
Day 3	Recognizes your coding style
Week 1	Writes in your voice
Week 2	Makes decisions like you would

Why AutoMem MCP?

vs. Building Your Own

✅ 2 years of R&D already done
✅ Research-validated architecture (HippoRAG 2, MELODI, A-MEM)
✅ Working integrations across all MCP platforms
✅ Active development and community

vs. Other Memory Solutions

✅ True graph relationships (not just vector similarity)
✅ Universal MCP compatibility (works with any MCP client)
✅ 7 memory types (Decision/Pattern/Preference/Style/Habit/Insight/Context)
✅ Self-hostable ($5/month vs $150+ for alternatives)

vs. Native AI Memory

✅ Persistent across sessions (not just context window)
✅ Cross-platform (same memory in Claude, Cursor, Code)
✅ Structured relationships (not just RAG)
✅ Infinite scale (no context window limits)

Real-World Results

Code Review That Knows Your Standards

Before AutoMem:
"Consider adding error handling here."

After AutoMem:
"Missing your standard try/except pattern. Based on your PR#127
review comments, you always wrap database calls with specific
logging for timeouts. Apply the same pattern here?"

Decisions With Context

Before AutoMem:
"Both approaches have tradeoffs..."

After AutoMem:
"You chose PostgreSQL over MongoDB for similar use case in Q1 2024.
Your decision memo cited team expertise and operational simplicity.
Same factors apply here - go with Postgres."

The Science Behind AutoMem

The AutoMem service implements cutting-edge 2025 research:

HippoRAG 2 (OSU, June 2025): Graph-vector approach achieves 7% better associative memory
A-MEM (July 2025): Dynamic memory organization with Zettelkasten principles
MELODI (DeepMind, 2025): 8x memory compression without quality loss
ReadAgent (DeepMind, 2024): 20x context extension through gist memories

This MCP package provides the bridge between your AI and that research-validated memory system.

Community & Support

💬 Discord - Join the community, get help, share feedback
🐦 X Community - Discussion and updates
📣 @automem_ai - Official announcements
📦 NPM Package - This MCP client
🔬 AutoMem Service - Backend repo with deployment guides
🐛 GitHub Issues - Bug reports and feature requests

Quick Links

MCP Client Setup

Installation Guide - MCP client setup for all platforms
Cursor Integration - IDE rules and configuration
Claude Code Setup - Memory rules integration
OpenAI Codex - Codex integration
Changelog - Release history

AutoMem Service

Service Repository - Backend source code
Service Installation - Local, Railway, Docker deployment

Contributing

We welcome contributions! Please:

Fork the repository
Create a feature branch
Make your changes with tests
Submit a pull request

📄 License

MIT - Because great memory should be free.

Ready to give your AI perfect memory?

npx @verygoodplugins/mcp-automem setup

Built with obsession. Validated by neuroscience. Powered by graph theory. Works with every MCP-enabled AI.

Designed by Jack Arturo at Very Good Plugins 🧡

Transform your AI from a tool into a teammate. Start now.

store_memory

Store memories with optional tags, importance scores, and metadata. Used to persist important information for future recall.

Parameters

content : string*

Description

The content of the memory to be stored. Should be specific: include context, reasoning, and results.

Parameters

tags : array*

Description

Tags for classifying memories (e.g., ["Project Name", "Error Fix", "Authentication"]).

Parameters

importance : number*

Description

Importance score: 0.9+ for critical decisions, 0.7 - 0.9 for patterns/errors, 0.5 - 0.7 for minor notes.

Parameters

embedding : array*

Description

Optional embedding vector for semantic search (automatically generated if omitted).

Parameters

metadata : object*

Description

Optional structured metadata (e.g., { files_modified: ["auth.ts"], error_type: "timeout" }).

Parameters

timestamp : string*

Description

Optional ISO timestamp (default is now).

Parameters

type : string*

Description

Memory type for classification.

Parameters

confidence : number*

Description

Classification confidence (0 - 1, default is 0.9 when type is provided).

Parameters

id : string*

Description

Custom memory ID (automatically generated if omitted).

Parameters

t_valid : string*

Description

ISO 8601 timestamp when the memory becomes valid.

Parameters

t_invalid : string*

Description

ISO 8601 timestamp when the memory expires.

Parameters

updated_at : string*

Description

ISO 8601 last update timestamp.

Parameters

last_accessed : string*

Description

ISO 8601 last accessed timestamp.

recall_memory

Search and retrieve relevant memories using semantic search, keywords, tags, time filters, and graph expansion. This is the main tool for accessing stored knowledge.

Parameters

query : string*

Description

Semantic search query (natural language). Describe what you are looking for.

Parameters

queries : array*

Description

Multiple queries for broader recall. Results are deduplicated on the server side.

Parameters

embedding : array*

Description

Optional embedding vector for direct similarity search.

Parameters

limit : integer*

Description

Maximum number of memories to return (default: 5, increase for broader context).

Parameters

time_query : string*

Description

Natural language time filter: "Today", "Yesterday", "Last week", "Last 30 days".

Parameters

start : string*

Description

Lower bound ISO timestamp (alternative to time_query).

Parameters

end : string*

Description

Upper bound ISO timestamp.

Parameters

tags : array*

Description

Filter by tags. Use the project name as the first tag for scoping.

Parameters

tag_mode : string*

Description

"any" matches memories with any tag (default), "all" requires all tags.

Parameters

tag_match : string*

Description

"exact" for exact tag matching (default), "prefix" for prefix matching.

Parameters

expand_entities : boolean*

Description

Enable multi - hop reasoning through entity expansion. Find memories of people/places mentioned in the seed results. Used for questions like "What is the job of X's sister?".

Parameters

expand_relations : boolean*

Description

Follow graph relations from seed results to find relevant memories.

Parameters

auto_decompose : boolean*

Description

Automatically extract entities and topics from the query to generate supplementary searches.

Parameters

expansion_limit : integer*

Description

Maximum total number of expanded memories (default: 25).

Parameters

relation_limit : integer*

Description

Maximum number of relations to follow for each seed memory (default: 5).

Parameters

expand_min_importance : number*

Description

Minimum importance score for expanded results. Filter out low - relevance memories during graph/entity expansion. Recommended: 0.3 - 0.5 for broad context, 0.6 - 0.8 for focused results. Seed results are never filtered, only expanded results.

Parameters

expand_min_strength : number*

Description

Minimum relation strength to follow during graph expansion. Only traverse edges above this threshold. Recommended: 0.3 for exploratory, 0.6+ for high - confidence connections. Does not affect entity expansion.

Parameters

context : string*

Description

Context tag (e.g., "coding - style", "architecture"). Improves matching preference.

Parameters

language : string*

Description

Programming language hint (e.g., "python", "typescript"). Prioritize memories in a specific language.

Parameters

active_path : string*

Description

Current file path for automatic language detection (e.g., "src/auth.ts").

Parameters

context_tags : array*

Description

Priority tags to boost in the results (e.g., ["coding - style", "preferences"]).

Parameters

context_types : array*

Description

Priority memory types to boost in the results (e.g., ["Style", "Preference"]).

Parameters

priority_ids : array*

Description

Specific memory IDs to ensure inclusion in the results.

Parameters

per_query_limit : integer*

Description

Result limit per query when using queries[] (default: 5).

Parameters

sort : string*

Description

Result sorting (use time_* for chronological review).

Parameters

format : string*

Description

Output format: text (default), items (each memory), detailed (with metadata), json (raw).

Parameters

offset : integer*

Description

Result offset for pagination.

associate_memories

Create typed relationships between two memories. This builds a knowledge graph, improving recall by showing relevant context.

Parameters

memory1_id : string*

Description

ID of the source memory (from store_memory response or recall results).

Parameters

memory2_id : string*

Description

ID of the target memory to link to.

Parameters

type : string*

Description

Relationship type between the two memories.

Parameters

strength : number*

Description

Relationship strength: 0.9+ for direct causal relationship, 0.7 - 0.9 for strong relationship, 0.5 - 0.7 for medium relationship.

update_memory

Update the content, tags, importance, or metadata of an existing memory. Use this function to correct or enhance memories instead of storing duplicates.

Parameters

memory_id : string*

Description

ID of the memory to update (from store_memory or recall results).

Parameters

content : string*

Description

New content (replaces existing content).

Parameters

tags : array*

Description

New tags (replaces existing tags).