xgmem MCP Memory Server: Scalable, Disk-Persistent Knowledge Graph Storage

Overview: What is xgmem MCP Memory Server?

xgmem is a TypeScript-based Model Context Protocol (MCP) server designed to enable project-specific and knowledge graph-based memory for AI applications such as Claude Desktop, Continue, Cursor, and other tools. This server supports storing, retrieving, and managing entities, relations, and observations per project, with a strong focus on flexibility and cross-project knowledge sharing.

🔧 Core Features & MCP Capabilities

xgmem provides robust capabilities to leverage the Model Context Protocol (MCP). It offers comprehensive CRUD operations through MCP tools, ensuring seamless integration with various AI applications. The server is built to be both scalable and persistent, storing all project memory in a disk-based JSON file (memory.json). This design ensures that data remains intact even when the system restarts. Additionally, xgmem leverages Docker for deployment, making it easy to containerize and run in any environment.

⚙️ MCP Architecture & Protocol Implementation

The architecture of xgmem is designed to be fully compliant with the Model Context Protocol (MCP). It consists of a series of tools that allow AI applications to interact with project-specific data. These tools include save_project_observations, get_project_observations, and many more, enabling a wide range of operations such as adding entities, relations, and observations.

MCP Protocol Flow Diagram

graph TD
    A[AI Application] -->|MCP Client| B[MCP Protocol]
    B --> C[xgmem Server]
    C --> D[Data Source/Tool]
    style A fill:#e1f5fe
    style C fill:#f3e5f5
    style D fill:#e8f5e8

MCP Client Compatibility Matrix

MCP Client	Resources	Tools	Prompts	Status
Claude Desktop	✅	✅	✅	Full Support
Continue	✅	✅	✅	Full Support
Cursor	❌ (Tools Only)	✅ (Tools Only)	❌ (No Prompts Supported)	Tools Only

🚀 Getting Started with Installation

To get xgmem up and running, follow these steps:

1. Install Dependencies: Run npm install to set up the necessary dependencies.
2. Build the Project: Use npm run build to compile the TypeScript files into JavaScript.
3. Development: To start the server in development mode, run npx ts-node index.ts.
4. Production: For a more streamlined startup experience, use npm start to launch it.

Docker Integration

xgmem can also be deployed via Docker for ease of deployment and management:

1. Build the Docker image: docker build -t xgmem-mcp-server .
2. Run the container: docker run -v $(pwd)/memories:/app/memories xgmem-mcp-server

💡 Key Use Cases in AI Workflows

Real-World Scenario 1: Entity and Relation Management

Suppose you are working on an AI tool that needs to understand the relationships between different entities. You can use xgmem to store these relations as knowledge graphs, which can be easily queried and modified.

Technical Implementation: To add a relationship, run the create_relations tool with appropriate parameters. For example, adding a relation between "Alice" and "Bob" in a project named "demo-project".

{
  "name": "create_relations",
  "args": {
    "projectId": "demo-project",
    "relations": [
      {"entity1": "Alice", "relType": "works with", "entity2": "Bob"}
    ]
  }
}

Real-World Scenario 2: Project-Specific Knowledge Storage

Consider a scenario where multiple AI applications need to collaborate on a project. xgmem can serve as a unified memory store, allowing each tool to access and update the same knowledge base.

Technical Implementation: To save project-specific observations, use the save_project_observations tool. Here’s an example of saving some text-based observations for "Alice" in the project:

{
  "name": "save_project_observations",
  "args": {
    "projectId": "demo-project",
    "observations": [
      {"entityName": "Alice", "contents": ["Joined Acme Corp in 2021.", "Is a software engineer."]}
    ]
  }
}

🔌 Integration with MCP Clients

xgmem is compatible with the following MCP clients:

• Claude Desktop: Fully supported with real-time updates and resource management.
• Continue: Supports full tooling integration.
• Cursor: Currently supports basic tools but lacks prompt-based interaction.

By integrating xgmem into your project, you can ensure that all AI applications have access to a shared knowledge base. This seamless integration enhances collaboration and efficiency across different development environments.

📊 Performance & Compatibility Matrix

xgmem is designed for high performance and compatibility with various MCP clients. The server leverages persistent storage mechanisms to ensure data integrity even during system restarts.

Example Configuration Code Sample

Here’s how to configure xgmem in your MCP settings:

{
  "mcpServers": {
    "xgmem": {
      "command": "npx",
      "args": ["-y", "xgmem@latest"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

This configuration ensures that xgmem is properly integrated into your project, ready to handle MCP requests.

🛠️ Advanced Configuration & Security

For advanced users, you can customize the environment settings and security configurations:

• Memory Directory: Change the default memory storage directory via MEMORY_DIR_PATH environment variable.
• Security Measures: Implement access control and other security protocols as needed for sensitive data.

❓ Frequently Asked Questions (FAQ)

1. How do I ensure data persistence?

   • xgmem uses disk-based JSON files to store project observations, ensuring persistence even after system restarts.

2. Can multiple AI applications access the same knowledge base concurrently?

   • Yes, xgmem supports concurrent access from multiple MCP clients, maintaining data integrity through proper locking mechanisms.

3. Is xgmem compatible with all MCP tools?

   • While most common tools are supported, some niche features might require additional configuration.

4. How can I secure my xgmem instance against unauthorized access?

   • Use environment variables and security best practices to restrict access to the server, such as setting appropriate API_KEY.

5. What happens if an observation is accidentally modified or deleted?

   • The data can be recovered by restarting the server with the original backup memory.json file.

👨‍💻 Development & Contribution Guidelines

Contributors are welcome to enhance and improve xgmem. To contribute, follow these steps:

1. Fork the Repository: Start by forking the official GitHub repository.
2. Create a Branch: Create a new branch for your modifications.
3. Commit Changes: Make sure to commit all changes with clear, descriptive messages.
4. Run Tests: Ensure that all tests pass before submitting a pull request.
5. Submit a Pull Request: Once ready, submit a pull request detailing the changes and improvements.

🌐 MCP Ecosystem & Resources

For more information on the Model Context Protocol and its integration with AI applications, visit the official Model Context Protocol (MCP) documentation. Additionally, explore resources and tools available for developers building advanced AI workflows.

By leveraging xgmem as your MCP server, you can significantly enhance the functionality and collaboration of AI applications across various projects and teams. This comprehensive setup ensures a seamless experience for developers integrating complex knowledge management systems into their work.