AI・10 min read・Posted on April 10, 2025 # The Claude you’ll never need to remind: MCP in action ![The Claude you’ll never need to remind: MCP in action](/sites/default/files/remediation-media/67fe13f607e9cac5657ce3c3_Enhancing_Claude___s_with_In-conversation_reasoning_-_the_sequentialThinking_MCP_server.avif) Table of contents - [Understanding Claude’s limitations](#understanding-claude-s-limitations) - [Context window limitations](#context-window-limitations) - [Session Amnesia](#session-amnesia) - [Manual file handling](#manual-file-handling) - [MCP: the solution](#mcp-the-solution) - [Setting up your environment](#setting-up-your-environment) - [Prerequisites](#prerequisites) - [Locating Claude’s configuration file](#locating-claude-s-configuration-file) - [Step-by-Step: memory MCP integration](#step-by-step-memory-mcp-integration) - [Step-by-Step: Filesystem MCP integration](#step-by-step-filesystem-mcp-integration) - [Understanding what’s happening behind the scenes](#understanding-what-s-happening-behind-the-scenes) - [How memory MCP works](#how-memory-mcp-works) - [How filesystem MCP works](#how-filesystem-mcp-works) - [How the MCPs work together](#how-the-mcps-work-together) - [The Claude experience after integration](#the-claude-experience-after-integration) - [Memory persistence](#memory-persistence) - [File access capabilities](#file-access-capabilities) - [Troubleshooting common issues](#troubleshooting-common-issues) - [Configuration problems](#configuration-problems) - [Permission problems](#permission-problems) - [Memory MCP issues](#memory-mcp-issues) - [Filesystem MCP issues](#filesystem-mcp-issues) - [Advanced tips and customization](#advanced-tips-and-customization) - [Customizing memory structure](#customizing-memory-structure) - [Creating automated workflows](#creating-automated-workflows) - [Conclusion](#conclusion) - [From opinion to potential](#from-opinion-to-potential) - [Official documentation and resources](#official-documentation-and-resources) 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**](https://github.com/modelcontextprotocol/servers/tree/main/src/memory): Enables persistent memory across conversations - [**Filesystem MCP**](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem): 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: 1. Close Claude completely 2. Restart Claude Desktop 3. 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: 1. Tell Claude something about yourself: “My name is \[your name\] and I work as a \[your profession\].” 2. End the conversation and start a new one 3. 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: 1. Log into your Claude account 2. Go to Settings > Profile 3. 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: 1. Close Claude completely 2. Restart Claude Desktop 3. 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: 1. Store information about entities (people, projects, concepts) 2. Track relationships between these entities 3. Maintain a history of conversations 4. 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: 1. List directories 2. Read file contents 3. Write or append to files 4. Delete files (when necessary) 5. Create directories When you ask Claude to perform a file operation, it: 1. Recognizes the request requires filesystem access 2. Checks if it has permission for the requested directory 3. Asks for your confirmation before accessing files 4. Uses the appropriate Filesystem MCP tool to execute the operation 5. Returns the results to you ### How the MCPs work together One powerful aspect of this setup is how these MCPs work together: 1. Memory MCP provides persistent memory through memory.json 2. Filesystem MCP allows Claude to read and write to this memory.json file 3. 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: 1. **Listing files**: “What files do I have in my Documents folder?” 2. **Reading files**: “Please read my meeting\_notes.txt file” 3. **Creating files**: “Save this summary to a new file called project\_summary.txt” 4. **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: 1. Have Claude analyze a document and store insights in memory 2. Use memory to inform how Claude processes future documents 3. Create summary files based on multiple inputs and memory 4. 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](https://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](https://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. Written by Souvik Pal Senior Engineer - Backend Editor Ananya Rakhecha, Tech Advocate ## We'd love to talk about your business objectives [ Contact Us ](/contact)