MemDx MCP: Persist Project Memory for VS Code/Cursor, Support Semantic Search & Agent Integration

Memdx

MemDx is a local and private memory layer extension designed for VS Code/Cursor. It deploys Qdrant and Ollama through Docker, providing persistent project context memory for AI, and supporting semantic search and Cursor Agent integration.

Knowledge management and memory Developer tools #Local Memory #AI Context #Semantic Search #Cursor Integration .TypeScript

rating : 2 points

downloads : 3.7K

update time : 2026-03-12

Open Site

What is MemDx Memory Layer?

MemDx is a memory extension designed for developers and AI assistants. It's like a smart notebook that can remember important information in your project, such as architectural decisions, code rules, and project structures. When collaborating with an AI assistant (e.g., Cursor's Agent), MemDx can provide persistent context, allowing the AI to'remember' previously discussed content without the need for repeated explanations.

How to use MemDx?

MemDx is designed to be very simple and easy to use: 1) Install the extension and run the setup wizard; 2) Select code or text, right-click and save it as a memory; 3) Search for saved memories using natural language; 4) Configure Cursor AI integration to allow the Agent to automatically use your memory library. The entire process runs completely locally to protect your privacy.

Use cases

MemDx is particularly suitable for the following scenarios: maintaining consistency in long - term project development, sharing project knowledge in team collaboration, recording architectural decisions in complex systems, understanding project rules when learning a new codebase, and having persistent context for in - depth collaboration with AI assistants.

Main Features

Persistent Context

Save and recall project decisions, rules, and architectures across sessions, enabling the AI assistant to have 'long - term memory'

100% Local and Private

Run locally using Docker (Qdrant + Ollama). All data stays on your device, ensuring privacy and security.

Semantic Search

Search for memories using natural language without the need for exact keyword matching. It understands the intention and meaning of the query.

Cursor Agent Integration

Seamlessly integrate with Cursor's Agent (Composer) through the MCP protocol. The AI assistant can automatically read and write memories.

Zero - Configuration Setup

The built - in setup wizard automatically handles all configurations, including starting Docker containers and initializing services.

Smart Indexing

Automatically index README.md,.cursorrules, and project structures with one click to quickly establish an initial memory library.

Advantages

Runs completely locally. Data never leaves your device, providing excellent privacy.

Deeply integrated with Cursor AI, enhancing the AI assistant's context understanding ability.

Simple setup. Wizard - style configuration lowers the usage threshold.

Supports natural language search, making it more intuitive to find memories.

Isolates memories across projects to avoid information confusion.

Limitations

Requires installing Docker Desktop, which occupies some system resources.

Needs to download the AI model for the first use, which may take a few minutes.

Currently mainly targets the VS Code/Cursor environment, with limited support for other editors.

Local storage capacity is limited by the device and is not suitable for storing a large amount of data.

How to Use

Installation and Setup

Install MemDx from the VS Code/Cursor extension market. When running it for the first time, click 'Setup Now' or run the 'MemDx: Quick Setup Wizard' command. Enter the user ID and project ID to complete the initialization.

Add Memory

Select the text (code, comments, decisions, etc.) you want to save in the editor. Right - click and select 'MemDx: Add Memory from Selection', or use the command panel to add it.

Search Memories

Use the command panel to search for saved memories. You can describe what you want to find in natural language, and the system will return semantically relevant memory entries.

Configure Cursor AI Integration

To allow Cursor's Agent to automatically use memories, you need to copy the MCP configuration and paste it into Cursor's MCP settings. After that, the AI assistant can read and write your memory library.

Index Project

Quickly establish a project memory library. Automatically save README.md,.cursorrules, and project structure information to memory with one click.

Usage Examples

Record Architectural Decisions

After team discussions, save important architectural decisions to memory to ensure that all members and AI assistants can remember these decisions.

Understand Project Specifications

Save the project's code specifications, naming conventions, and best practices as memories to help new members and AI assistants quickly adapt to the project.

Maintain Context Across Sessions

Maintain the continuity of discussions across multiple development sessions to avoid repeating explanations of the same concepts and decisions.

Quickly Get Started with a New Project

When joining a new project, use the smart indexing function to quickly understand the project structure and important documents.

Frequently Asked Questions

Does MemDx require an internet connection?

How can I ensure the privacy of my data?

What should I do if I encounter a 'Vector Dimension Error'?

Which AI models does MemDx support?

Can I use MemDx in multiple projects?

How can I back up my memory data?

Will MemDx affect the performance of VS Code?

Related Resources

MemDx GitHub Repository

The source code and latest version of MemDx

Model Context Protocol Documentation

The official documentation and specifications of the MCP protocol

Docker Desktop Download

The Docker environment required to run MemDx

Cursor Editor Official Website

The AI code editor that MemDx is mainly integrated with

MemDx Usage Tutorial Video

Video tutorial on the installation and use of MemDx

🚀 MemDx Memory Layer for Cursor

A powerful VS Code/Cursor extension that integrates a local, private memory layer (formerly Mem0) to provide persistent AI context for your projects. MemDx helps your AI remember important decisions, code patterns, and project structure across sessions.

✨ Features

🧠 Persistent Context: Store and recall project decisions, rules, and architecture.
🔒 100% Local & Private: Runs on your machine using Docker (Qdrant + Ollama). No data leaves your device.
🔍 Semantic Search: Find relevant memories using natural language.
🚀 Cursor Agent Integration: Seamlessly works with Cursor's Agent (Composer) via MCP.
⚡ Zero Config Setup: Built-in Setup Wizard handles everything.
📝 Smart Indexing: One-click to index your README.md, .cursorrules, and project structure.

🚀 Quick Start

1. Prerequisites

Docker Desktop installed and running.
Node.js (v18+) (for the MCP server).

2. Installation

Install this extension from the Marketplace or VSIX.
When prompted, click "Setup Now" or run command MemDx: Quick Setup Wizard.
Enter a User ID (e.g., your name) and Product ID (your project name).

3. Usage

Add Memory: Select code/text -> Right click -> MemDx: Add Memory from Selection.
Search: Ctrl+Shift+P -> MemDx: Search Memories -> Type query (e.g., "authentication logic").
View All: Ctrl+Shift+P -> MemDx: View All Memories.

💻 Usage Examples

Basic Usage

# No specific code example provided in the original, so this is just a placeholder for illustration
# You can add relevant code snippets if available
# For example, if there was a code to add memory
# add_memory("This is a sample memory")

📚 Documentation

Setup Cursor AI (MCP) Integation

To let Cursor's Agent (Composer) read/write memories automatically:

Press Ctrl+Shift+P and run MemDx: Copy MCP Config for Cursor.
Open Cursor Settings (gear icon) -> Features -> MCP.
Paste the config into the MCP settings editor.
Click Add.

Now you can type @MemDx Memory Layer in chat, or just ask the Agent:

"Save this architectural decision to memory" "What did we decide about error handling? Search memory."

Commands

Property	Details
`MemDx: Quick Setup Wizard`	Run first-time setup (User/Product IDs, start Docker)
`MemDx: Start Service`	Spin up the local memory backend (Docker)
`MemDx: Add Memory`	Save selected text to memory
`MemDx: Search Memories`	Semantic search through your saved context
`MemDx: Index Project`	Automatically saves README, rules, and structure to memory
`MemDx: Copy MCP Config`	Generates the JSON needed for Cursor integration
`MemDx: View Logs`	See what the backend is doing
`MemDx: Reset Service`	Fix DB issues by wiping local data (use if you see dimension errors)

Configuration

You can customize these in VS Code Settings:

memdx.userId: Your unique identifier.
memdx.productId: Project identifier (allows separating memories by project).
memdx.autoStart: Automatically start backend on launch (default: false).

Troubleshooting

"Memories map is not a function" / Vector Dimension Error

If you switched models or versions, your database might have a dimension mismatch. Fix: Run command MemDx: Reset Service (Fix DB). This wipes the local Qdrant data and restarts cleanly.

"Model not found"

The first time you run MemDx, it downloads AI models (qwen2.5, nomic-embed-text) inside Docker. This takes a few minutes. Check status with MemDx: Check Service Status.