G0t4 MCP Server Memory File

This project is an MCP server for managing memory text files, helping AI models like Claude maintain context between conversations. It provides functions to add, search, delete, and list memories, supporting exact matching operations based on substrings. It is designed to store memories in simple text files, similar to ChatGPT's memory mechanism, and triggers memory storage through prompts and training.

Knowledge management and memory Artificial intelligence chatbots #Memory management #Context preservation #MCP service #Text storage Local .TypeScript

rating : 2.5 points

downloads : 20

update time : 2025-04-29

What is MCP Memory Server?

This service acts as an external memory bank for AI assistants, allowing them to store and recall important information across different conversations. It maintains a simple text file where each line represents a discrete memory that the AI can reference in future interactions.

How does it work?

The AI assistant uses special commands to add, search, or delete memories during conversations. These memories persist between chat sessions and help the AI maintain context about you and your preferences.

When to use it?

Ideal for maintaining personal context with AI assistants, remembering preferences between sessions, or recording successful solutions to recurring problems.

Key Features

Memory OperationsSupports adding, searching, listing and deleting memories through simple commands

Text-Based StorageMemories stored as plain text lines for simplicity and compatibility

Cross-Session MemoryMemories persist between different conversation sessions

Pros and Cons

Advantages

Simple and lightweight implementation

Human-readable memory format

No complex database requirements

Easy to integrate with existing AI systems

Limitations

Basic substring matching only (no advanced search)

No built-in memory expiration

No automatic memory prioritization

Requires explicit AI training/prompting to use effectively

Usage Guide

Initialize Server

Start the MCP memory server with default configuration

Add Memories

The AI can store important information as text memories

Recall Memories

Query stored memories when context is needed

Example Scenarios

Remembering Personal DetailsThe AI stores and recalls personal information shared in conversation

Technical PreferencesRecording successful commands or configurations

Context CorrectionUpdating outdated information

Frequently Asked Questions

How are memories different from chat history?

Can I edit memories directly?

How many memories can be stored?

Do memories expire automatically?

Additional Resources

MCP Protocol Documentation

Official documentation for the Model Context Protocol

Memory Server GitHub Repository

Source code and issue tracker

AI Memory Best Practices

Guide to effective memory usage with AI systems

🚀 MCP Server Memory

This is an MCP server that interacts with a memory text file to assist Claude in cross-chat context management.

Each line represents a piece of memory.

These tools enable Claude (and other MCP clients) to manage memories during a chat:

memory_add(memory: string) - Add a memory.
memory_search(query: string) - Return matching memories (exact substring match) - Wildcards/regular expressions may be supported in the future.
memory_delete(query: string) - Delete matching memories (exact substring match).
memory_list() - Return all memories.
Note: memory_update == memory_delete + memory_add.

For example:

I mention my name => "Chatting with Wes".
Mention my daughter's age => "Wes's daughter is 8 years old".
Say I'm working on a TypeScript project => "Working on a TypeScript project".
Moreover, it's important to base on what Claude (the assistant/LLM) says or does...
- Especially tool usage (i.e., run_command). For instance, when the first attempt to use a tool fails (e.g., the python command doesn't exist), and then python3 is used successfully later => Claude can record "Used python3, python was not available".
I ask Claude to delete memories about X => memory_delete(query: X).
I correct my name => memory_search("oldname") + Delete each matching item or common subset query + Add the new name.

Then, when starting a new chat, Claude will automatically retrieve the most recent memories (subset or all) or can request memories (partial/more/all). These memories can then influence responses, tool usage, etc.

✨ Features

📚 Design

A simple memory text file is used for the following reasons:

ChatGPT's memory works well and is essentially a text file.
- Although it may be structured behind the scenes, when you view the memories, they are presented as a text file.
It worked well when I tested it in the mcp-server-commands for a similar reminder feature (when Claude had access to them).
Unstructured text simplifies the management of tools and parameters, essentially managing a list of strings.

💡 Prompt Mechanism

It's crucial to have a prompt to let the model know when to store memories. However, it's not clear how to do this best...
Training: OpenAI acknowledges that some training teaches the model when to store memories, similar to how the model is trained for tool usage.
Prompt: The system prompt section may include a reminder to trigger memory storage.
The tools themselves: In my tests with Claude, I couldn't get it to store memories based solely on tool specifications or prompts/suggestions in tool responses. So, relying solely on tools is not enough. I believe adding a prompt in the prompt section would be effective.

🔮 Future Plans/Ideas

I'm not sure if these are worth the effort. I'm just listing some future ideas, maybe to stop myself from implementing them :)

Freshness factor: A way to reorder memories based on freshness?
- Order becomes relevant in this case, especially for fuzzy memory queries (e.g., when working on a TypeScript project and a Python project, and I ask to start a new project, it might suggest the one used most recently).
Gradually fade out old memories?