Ever had a deep, productive conversation with Claude—only to lose all that context when you start a new chat? Or wish Claude could remember details about you and your projects from one session to the next? Maybe you’ve wanted Claude to manage your files without constantly copying and pasting content, or edit them directly from Claude’s interface itself.
These limitations can get in the way of real efficiency. That’s where the Model Context Protocol (MCP) comes in.
This guide will show you how to integrate two powerful MCP servers with Claude to expand its capabilities:
- Memory MCP: Enables persistent memory across conversations
- Filesystem MCP: Let Claude read, write, and manage files directly
By the end, Claude won’t just respond within a session—it will remember, organize, and help across all your workflows.
Let’s get started.
Understanding Claude’s limitations
Before diving into the solution, let’s identify the problems we’re solving:
Context window limitations
Claude has a finite context window - meaning it can only “see” a certain amount of text at once. When a conversation gets too long, Claude loses access to earlier parts, forcing you to either:
- Summarize previous information
- Copy/paste important details repeatedly
- Start over with a new conversation
Session Amnesia
Standard Claude has no persistent memory between conversations at the time of writing this article. Each new chat starts with a blank slate, requiring you to reintroduce yourself, your preferences, and your projects every time.
Manual file handling
Without filesystem access, you need to manually copy content between Claude and your files. This creates friction when:
- Working with multiple documents
- Updating files based on Claude’s suggestions
- Having Claude analyze file contents
MCP: the solution
The Model Context Protocol (MCP) addresses these limitations by standardizing how AI applications like Claude connect to external tools and data sources.
Think of it like a docking hub for your laptop - one standardized connection that gives access to multiple capabilities.
We’ll focus on two particular MCPs:
Memory MCP solves the persistence problem by:
- Storing information about you, your preferences, and important context
- Maintaining a persistent memory.json file between conversations
- Letting Claude access historical information without keeping it all in the current context
Filesystem MCP enhances Claude’s capabilities by:
- Providing secure access to specified directories on your computer
- Allowing Claude to read, write, and manage files directly
- Eliminating the need for constant copying and pasting
Together, these MCPs transform Claude into a much more capable assistant with both memory and the ability to interact with your files.
Setting up your environment
Prerequisites
To follow this guide, you’ll need:
- Claude Desktop installed
- Node.js and npm installed
- Basic understanding of JSON configuration
- Access to edit system configuration files
Locating Claude’s configuration file
Claude’s MCP configuration is stored in a JSON file. The location depends on your operating system:
On macOS:
~/Library/Application Support/Claude/claude-desktop-config.json
On Windows:
%APPDATA%\Claude\claude-desktop-config.json
On Linux:
~/.config/Claude/claude-desktop-config.json
In my setup, I’ve created a dedicated directory for Claude MCP configurations at:
/Users/username/claude-mcp-configs/
This is where I’ll store both the memory.json file and any additional MCP-related configurations.
Step-by-Step: memory MCP integration
Step 1: install the Memory MCP plugin
First, we need to install the Memory MCP plugin globally:
npm install -g @mcp-plugins/memory
Step 2: Create initial memory file
Create a directory to store your memory file (if it doesn’t already exist):
mkdir -p /Users/username/claude-mcp-configs
Create an initial memory.json file with a basic structure:
echo '{
"entities": [],
"relations": [],
"conversations": []
}' > /Users/username/claude-mcp-configs/memory.json
Step 3: Configure memory MCP in Claude
To update Claude’s configuration to use the Memory MCP, start by opening its configuration file in a text editor. You can locate this file by navigating to Claude Settings > Developer > and then selecting Edit Config. This will open the claude-config.json file for editing.
If the file doesn’t exist yet or is empty, create it with this initial structure:
{
"mcp_servers": []
}
Then add the Memory MCP configuration to the mcp_servers array:
{
"mcp_servers": [
{
"name": "memory",
"command": "npx",
"args": [
"@mcp-plugins/memory",
"--memory-file",
"/Users/username/claude-mcp-configs/memory.json"
]
}
]
}
This configuration tells Claude:
- To use a server named “memory”
- To run it using the npx command (which executes Node.js packages)
- To use the @mcp-plugins/memory package
- To store memory in the specified file path
Step 4: Restart Claude and test memory MCP
After saving the configuration:
- Close Claude completely
- Restart Claude Desktop
- Check if the Memory MCP is running in Settings > Developer
When properly configured, you should see “memory” listed as a running MCP server.
To test if it’s working, try a simple interaction:
- Tell Claude something about yourself: “My name is [your name] and I work as a [your profession].”
- End the conversation and start a new one
- Ask Claude: “What do you remember about me?”
If the Memory MCP is working correctly, Claude should recall information from your previous conversation!
Step-by-Step: Filesystem MCP integration
Step 1: Install the filesystem MCP plugin
Install the Filesystem MCP plugin globally:
npm install -g @mcp-plugins/file-system
Step 2: Configure filesystem MCP in Claude
Edit Claude’s configuration file again, adding the Filesystem MCP to the mcp_servers array:
{
"mcp_servers": [
{
"name": "memory",
"command": "npx",
"args": [
"@mcp-plugins/memory",
"--memory-file",
"/Users/username/claude-mcp-configs/memory.json"
]
},
{
"name": "file_system",
"command": "npx",
"args": [
"@mcp-plugins/file-system",
"--allow-dirs",
"allow the directories that you want to be accessible",
]
}
]
}
This configuration:
- Creates a server named “file_system”
- Uses the @mcp-plugins/file-system package
- Grants Claude access to specific directories (/Users/username/claude-mcp-configs and /Users/username/Documents)
Security Note: Be careful which directories you allow Claude to access. Only include directories where it’s safe for Claude to read and write files.
Step 3: Configure the memory MCP prompt
The Memory MCP requires a specific prompt to function correctly. While the GitHub repository suggests placing this in the “Instructions” field, you can also add it to your Claude profile settings. That’s what I did:
- Log into your Claude account
- Go to Settings > Profile
- Add the following prompt to your profile:
Follow these steps for each interaction:
1. User identification:
- You should assume that you are interacting with default_user
- If you have not identified default_user, proactively try to do so.
2. Memory retrieval:
- Always begin your chat by saying only "Remembering..." and retrieve all relevant information from your knowledge graph
- Always refer to your knowledge graph as your "memory"
3. Memory capture:
- While conversing with the user, be attentive to any new information that falls into these categories:
a) Basic Identity (age, gender, location, job title, education level, etc.)
b) Behaviors (interests, habits, etc.)
c) Preferences (communication style, preferred language, etc.)
d) Goals (goals, targets, aspirations, etc.)
e) Relationships (personal and professional relationships up to 3 degrees of separation)
4. Memory update:
- At the end of each response, update your memory with any new information gathered during the interaction
- Create entities for recurring organizations, people, and significant events
- Connect them to the current entities using relations
- Store facts about them as observations
Step 4: Restart Claude and test filesystem MCP
After saving the configuration:
- Close Claude completely
- Restart Claude Desktop
- Check if both MCPs are running in Settings > Developer
When properly configured, you should see both “memory” and “file_system” listed as running MCP servers.
To test if the Filesystem MCP is working, try these commands:
- “List the files in my Documents folder”
- “Read the content of my memory.json file in the claude-mcp-configs directory”
Claude should be able to execute these commands and show you the results!
The complete configuration
Here’s the complete configuration file for reference:
{
"mcp_servers": [
{
"name": "memory",
"command": "npx",
"args": [
"@mcp-plugins/memory",
"--memory-file",
"/Users/username/claude-mcp-configs/memory.json"
]
},
{
"name": "file_system",
"command": "npx",
"args": [
"@mcp-plugins/file-system",
"--allow-dirs",
"/Users/username/claude-mcp-configs",
"--allow-dirs",
"/Users/username/Documents"
]
}
]
}
Understanding what’s happening behind the scenes
How memory MCP works
Memory MCP creates and maintains a structured memory.json file that stores information in this format:
{
"entities": [
{
"type": "entity",
"name": "user",
"entityType": "Person",
"observations": [
"Name is username",
"Works as a software developer",
"Interested in AI and automation",
"Using macOS on their computer"
]
},
{
"type": "entity",
"name": "Project A",
"entityType": "Project",
"observations": [
"Due date is April 15th",
"Involves designing a recommendation system",
"Has high priority"
]
}
],
"relations": [
{
"type": "relation",
"from": "user",
"to": "Project A",
"relationType": "is working on"
}
],
"conversations": [
{
"date": "2025-04-02",
"summary": "Discussed Project A requirements and timeline. User asked about recommendation algorithms and we explored collaborative filtering options."
}
]
}
This structure allows Claude to:
- Store information about entities (people, projects, concepts)
- Track relationships between these entities
- Maintain a history of conversations
- Access this information across multiple chat sessions
Claude doesn’t need to keep all this information in its context window - it can query the memory when needed, effectively extending its memory far beyond the context limitations.
How filesystem MCP works
Filesystem MCP provides Claude with a set of tools to:
- List directories
- Read file contents
- Write or append to files
- Delete files (when necessary)
- Create directories
When you ask Claude to perform a file operation, it:
- Recognizes the request requires filesystem access
- Checks if it has permission for the requested directory
- Asks for your confirmation before accessing files
- Uses the appropriate Filesystem MCP tool to execute the operation
- Returns the results to you
How the MCPs work together
One powerful aspect of this setup is how these MCPs work together:
- Memory MCP provides persistent memory through memory.json
- Filesystem MCP allows Claude to read and write to this memory.json file
- This creates a system where:
- Claude can remember information across sessions
- You can manually inspect and edit the memory.json file if needed
- Claude can update its own memory by writing to the file
For example, you could ask Claude to:
- “Show me what you remember about Project A”
- “Update your memory about Project A to include a new deadline of May 1st”
- “Add a new entity called ‘Client B’ to your memory”
Claude would use both MCPs to execute these requests, creating a much more capable assistant.
The Claude experience after integration
After integrating these MCPs, here’s how your interaction with Claude changes:
Memory persistence
When you start a new conversation, Claude might say something like:
Remembering previous information about you...
I recall that:
- Your name is username
- You're working on Project A which has a deadline of April 15th
- You prefer technical explanations with examples
- You're interested in recommendation systems
How can I help you today?
This immediate recall creates continuity across conversations and eliminates the need to reintroduce yourself or provide context repeatedly.
File access capabilities
You’ll notice new capabilities related to file management:
- Listing files: “What files do I have in my Documents folder?”
- Reading files: “Please read my meeting_notes.txt file”
- Creating files: “Save this summary to a new file called project_summary.txt”
- Updating files: “Add today’s discussion points to my project_log.txt file”
When Claude performs these operations, you’ll see an interface element asking for permission to access your files. This security measure ensures Claude only accesses files with your explicit approval.
Troubleshooting common issues
Configuration problems
Issue: MCPs not showing as running in Claude’s developer settings
solutions:
- Check for JSON syntax errors in your configuration file
- Ensure the paths to your memory.json file and allowed directories are correct
- Verify that you’ve installed the MCP plugins correctly
- Make sure you’ve completely restarted Claude after making configuration changes
Issue: “Command not found” errors in logs
Solution: Ensure npx is installed and in your PATH. You might need to install Node.js or update your npm installation.
Permission problems
Issue: Claude can’t access specified directories
Solutions:
- Check the file permissions on the directories you’ve allowed
- Ensure the user running Claude has read/write access to these directories
- On macOS, you might need to grant Claude full disk access in System Preferences > Security & Privacy > Privacy
Memory MCP issues
Issue: Claude isn’t remembering information between sessions
Solutions:
- Verify memory.json exists and has the correct permissions
- Check if the file is being updated (the modification timestamp should change)
- Ensure the memory file path in config.json is correct
Filesystem MCP issues
Issue: Claude can access directories not specified in the configuration
Solution: This shouldn’t happen, but if it does, check your configuration and ensure you’re using --allow-dirs correctly rather than --allow-all-dirs which is less secure.
Advanced tips and customization
Customizing memory structure
You can manually edit memory.json to:
- Add entities Claude might not have created
- Organize information in a more structured way
- Remove outdated or incorrect information
Example: Add a new project entity manually:
{
"type": "entity",
"name": "Project B",
"entityType": "Project",
"observations": [
"Starting in May 2025",
"Will involve data migration",
"Expected timeline: 3 months"
]
}
Add this to the “entities” array in memory.json.
Creating automated workflows
With both MCPs, you can create powerful workflows:
- Have Claude analyze a document and store insights in memory
- Use memory to inform how Claude processes future documents
- Create summary files based on multiple inputs and memory
- Maintain project logs that persist between conversations
For example: “Read the project_requirements.txt file, compare it with what you remember about Project A, and create a summary of differences in a new file called requirement_changes.txt.”
Conclusion
By integrating Memory and Filesystem MCPs with Claude, we’re no longer dealing with a session-bound assistant—we’re stepping into a persistent, context-aware AI environment.
Two of the biggest limitations in traditional AI interactions are now meaningfully addressed:
• Context window restrictions are sidestepped through external memory access. Claude can reach beyond the fixed token limit and pull in relevant history on demand.
• Session amnesia—the need to repeat yourself or re-upload files—is eliminated. Claude builds a long-term memory of your projects, patterns, and preferences.
This shift makes Claude feel less like a chatbot and more like an intelligent agent embedded in your workflow.
With direct file system integration, it can locate, read, and reference your files based on memory—reducing friction and expanding its usefulness over time.
From opinion to potential
I see this setup as the early stages of a broader shift in how we use AI as an infrastructure layer for knowledge continuity and decision support. It echoes the intent behind projects like LangChain and AutoGPT but applies it in a way that’s more grounded and usable today.
Companies are already experimenting with similar architecture to build AI copilots that persist and evolve:
- Devin by Cognition recently introduced a software engineer agent with a memory model designed for full project lifecycles.
- Perplexity AI’s enterprise research assistant continues to push toward persistent knowledge systems for internal teams.
- Anthropic’s Claude Memory has started rolling out in the U.S. and UK, with broader expansion expected later in 2025.
These efforts are shaping a new class of agents—ones that aren’t just smart in the moment, but that grow with you over time.
Official documentation and resources
For more detailed information about the MCPs used in this guide, refer to the official GitHub repositories:
- Memory MCP: github.com/modelcontextprotocol/servers/tree/main/src/memory
- This repository contains the source code, documentation, and examples for the Memory MCP.
- It includes details about how to customize the memory structure and behaviour.
- Filesystem MCP: github.com/modelcontextprotocol/servers/tree/main/src/filesystem
- This repository provides documentation on all available filesystem commands.
- It includes security considerations and configuration options.
These repositories are maintained by the Model Context Protocol team and contain the most up-to-date information about each MCP’s capabilities and configuration options.