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:
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:
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:
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:
Filesystem MCP enhances Claude’s capabilities by:
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:
Locating Claude’s configuration file
Claude’s MCP configuration is stored in a JSON file. The location depends on your operating system:
On macOS:
On Windows:
On Linux:
In my setup, I’ve created a dedicated directory for Claude MCP configurations at:
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:
Step 2: Create initial memory file
Create a directory to store your memory file (if it doesn’t already exist):
Create an initial memory.json file with a basic structure:
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:
Then add the Memory MCP configuration to the mcp_servers array:
This configuration tells Claude:
Step 4: Restart Claude and test memory MCP
After saving the configuration:
When properly configured, you should see “memory” listed as a running MCP server.
To test if it’s working, try a simple interaction:
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:
Step 2: Configure filesystem MCP in Claude
Edit Claude’s configuration file again, adding the Filesystem MCP to the mcp_servers array:
This configuration:
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:
Step 4: Restart Claude and test filesystem MCP
After saving the configuration:
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:
Claude should be able to execute these commands and show you the results!
The complete configuration
Here’s the complete configuration file for reference:
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:
This structure allows Claude to:
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:
When you ask Claude to perform a file operation, it:
How the MCPs work together
One powerful aspect of this setup is how these MCPs work together:
For example, you could ask Claude to:
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:
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:
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:
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:
Memory MCP issues
Issue: Claude isn’t remembering information between sessions
Solutions:
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:
Example: Add a new project entity manually:
Add this to the “entities” array in memory.json.
Creating automated workflows
With both MCPs, you can create powerful workflows:
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:
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:
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.