Knowledge graph-based persistent memory system
## Memory MCP Server: Persistent Knowledge for AI Conversations The **Memory MCP Server** provides persistent memory capabilities for Google Antigravity, enabling the AI to remember information across conversations. Store user preferences, project context, and important facts that persist between sessions—making your AI assistant truly personalized. ### Why Memory MCP? AI assistants typically lose context when conversations end. The Memory MCP solves this fundamental limitation: - **Persistent Storage**: Information survives across sessions - **Contextual Recall**: AI remembers what you've told it - **Knowledge Building**: Accumulate project-specific knowledge - **Personalization**: Preferences and settings that stick - **Learning**: AI improves understanding over time ### Key Features #### 1. Information Storage Save important information: ``` "Remember that our API uses JWT authentication" "Store the fact that the database is PostgreSQL 15" "Note that we deploy to AWS us-east-1" "Save my preference for 2-space indentation" ``` The MCP stores: - Facts and statements - User preferences - Project configurations - Technical decisions - Important context #### 2. Contextual Recall Retrieve stored information naturally: ``` "What database are we using?" "What's my indentation preference?" "Remind me about the authentication setup" "What did we decide about the API structure?" ``` #### 3. Knowledge Organization Structure your stored knowledge: ``` "Create a memory category for project settings" "Group all deployment information together" "Tag this memory as security-related" "List all memories about the frontend" ``` #### 4. Memory Management Control what's remembered: ``` "Forget the old API endpoint" "Update the database version to 16" "Clear all memories about the deprecated service" "Export all project memories" ``` #### 5. Relationship Mapping Connect related information: ``` "Link the auth service to the user model" "Associate this configuration with production" "Connect the error handling to the logging system" ``` ### Configuration Set up Memory MCP: ```json { "mcpServers": { "memory": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-memory"], "env": { "MEMORY_FILE": "/path/to/memory.json" } } } } ``` ### Common Workflows #### Project Onboarding ``` 1. "Remember: this is a Next.js 14 project" 2. "Store: we use Tailwind for styling" 3. "Note: tests are in the __tests__ directory" 4. "Remember: deployment is via Vercel" ``` #### Personal Preferences ``` 1. "Remember I prefer TypeScript over JavaScript" 2. "Store my preference for functional components" 3. "Note that I like comprehensive error handling" 4. "Remember I want detailed comments" ``` #### Technical Decisions ``` 1. "Remember we chose PostgreSQL for ACID compliance" 2. "Store the decision to use GraphQL for the API" 3. "Note that we're using Redis for caching" ``` ### Memory Types #### Facts Objective information about your project: - Technology stack - Architecture decisions - Configuration details - External services #### Preferences Personal coding style and choices: - Formatting preferences - Naming conventions - Code organization - Documentation style #### Context Project-specific understanding: - Business logic - Domain concepts - Workflows - Constraints ### Best Practices 1. **Be Specific**: Store precise, actionable information 2. **Stay Current**: Update memories when things change 3. **Organize Well**: Use categories and tags 4. **Prune Regularly**: Remove outdated information 5. **Review Periodically**: Verify stored facts are accurate ### Integration Patterns #### Code Generation Memories improve code generation: ``` The AI remembers your stack and preferences, generating code that matches your project style without repeated explanations. ``` #### Debugging Context helps with troubleshooting: ``` "Based on what you told me about your auth setup, the issue is likely in the token validation..." ``` #### Documentation Consistent documentation: ``` Memories of project conventions ensure generated docs match existing style. ``` ### Privacy and Security - Memories are stored locally - No data sent to external servers - You control what's remembered - Easy to delete sensitive information - Backup and restore capabilities ### Advanced Features #### Semantic Search Find memories by meaning: ``` "Find memories related to authentication" "What do you know about our deployment?" "Search for database-related information" ``` #### Memory Confidence Track information reliability: - Verified facts vs. assumptions - Confidence levels - Source tracking - Timestamp information #### Cross-Project Memories Share common preferences: ``` "Remember globally: I prefer 2-space indentation" "Store project-specific: this uses 4-space indentation" ``` ### Use Cases #### Team Knowledge Base Build shared project knowledge: - Architecture decisions and rationale - Coding standards - Environment configurations - Common troubleshooting steps #### Personal Assistant Create a personalized experience: - Remember work patterns - Track ongoing tasks - Store frequently used commands - Remember preferences #### Learning System AI that learns about your project: - Accumulates understanding over time - Provides increasingly relevant suggestions - Reduces repetitive explanations The Memory MCP Server transforms Google Antigravity from a stateless assistant into a knowledgeable partner that truly understands your projects and preferences.
{
"mcpServers": {
"memory": {
"args": [
"-y",
"@modelcontextprotocol/server-memory"
],
"command": "npx"
}
}
}