MemGPT Sample MCP Server: Seamless Integration for AI Applications

This project implements a simplified and abridged version of the MemGPT research, showcasing its integration as both a REST service and an MCP server. It includes a ChatBot command line application that can interact with these mechanisms.

Overview: What is the MemGPT Sample MCP Server?

The MemGPT Sample MCP Server leverages Spring Boot and Spring AI to expose functionality as both a REST service and an MCP server. This implementation allows for seamless integration with various AI applications, providing a versatile platform for developing and deploying intelligent agents. By using this server, developers can integrate advanced cognitive capabilities into their applications through the Model Context Protocol (MCP), ensuring compatibility and enhanced performance.

🔧 Core Features & MCP Capabilities

The core-agent component is central to implementing the MemGPT concept. It defines and manages key aspects such as system prompts, tools, core memory, archival memory, and message persistence. Specifically, it handles:

Message Compilation: Compiling messages for communication with Language Models (LLMs).
Tool Calling: Invoking external tools based on user instructions.
Memory Management: Self-editing context windows to maintain relevant conversational history.
Message Retrieval & Archiving: Storing and retrieving past conversations for reference or archival purposes.
Message Summarization: Generating summaries of lengthy dialogues for convenience.

Extensive APIs allow external systems (such as the restful-agent-app, memgpt-mcp-server, and simple-chat-bot-app) to interact with these core functionalities. The MemGPT Sample MCP Server supports two main interactions: via REST and through an MCP server interface.

Mermaid Diagram: MCP Protocol Flow

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

Mermaid Diagram: Data Architecture

graph LR;
    subgraph MemoryLayer
        MemGPT::Agent[MemGPT Agent Instance]
        CoreMemory[Core Memory]
        ArchivalMemory[Arcival Memory]
    end
    subgraph ApplicationLayers
        MCPClient[MCP Client]
        RestServiceApp[REST Service App]
        CLIChatBot[CLI Chat Bot App]
    end
    MCPClient --> MemGPT::Agent
    RestServiceApp --> MemGPT::Agent
    CLIChatBot --> MemGPT::Agent

⚙️ MCP Architecture & Protocol Implementation

The MemGPT Sample MCP Server is meticulously architected to facilitate seamless integration across diverse AI applications. The architecture focuses on the following key components:

MCP Client: Tools like Claude Desktop, Continue, and Cursor can integrate with this server through the Model Context Protocol (MCP). Each client supports different functionalities as detailed in the compatibility matrix below.
REST Service App & CLI Chat Bot App: These applications can communicate with the MCP Server to manage context windows and generate chat completions more efficiently.

Mermaid Diagram: MCP Client Compatibility Matrix

table
|MCP Client       | Resources | Tools  | Prompts  | Status     |
|-----------------|-----------|--------|----------|------------|
|Claude Desktop   | ✅        | ✅     | ✅       | Full Support|
|Continue         | ✅        | ✅     | ✅       | Full Support|
|Cursor           | ❌        | ✅     | ❌       | Tools Only |

🚀 Getting Started with Installation

Steps to Run the MemGPT Sample MCP Server

Set Up Environment Variables:
```
export OPENAI_API_KEY=your-api-key
```

Build the Application:

For REST Service App:
```
./gradlew :restful-agent-app:build
```
For MCP Server:
```
./gradlew :memgpt-mcp-server:build
```

Run the MemGPT Sample MCP Server:

For REST Service App:

java -jar ./restful-agent-app/build/libs/restful-agent-app-0.0.1-SNAPSHOT.jar

For MCP Server:

java -jar ./memgpt-mcp-server/build/libs/memgpt-mcp-server-0.0.1-SNAPSHOT.jar

The server will then be ready to accept incoming transactions from the ChatBot application or any compatible client.

💡 Key Use Cases in AI Workflows

Real-World Scenario 1: Personal Assistant for Knowledge Workers

Imagine a knowledge worker using an advanced AI assistant that can process extensive research, draft emails, and manage complex projects. By integrating the MemGPT Sample MCP Server with their preferred device (e.g., Continue), they can benefit from:

Contextual Awareness: The assistant remembers past interactions and ongoing projects automatically.
Productivity Enhancements: Seamless tool usage and intelligent summarizations save time.

Real-World Scenario 2: Customer Support Tool for Enterprises

An enterprise may deploy a chatbot that operates as customer support through a website. By integrating with the MemGPT Sample MCP Server, this chatbot can:

Enhanced Conversational History: Retain context across multiple interactions.
Dynamic Tool Integration: Use external tools to resolve inquiries faster.

🔌 Integration with MCP Clients

The MemGPT Sample MCP Server is designed for seamless integration with various MCP clients. For instance, the rest and mcp profiles in your configuration allow you to specify which server the simple-chat-bot-app should communicate with:

# application.yaml snippet
spring.profiles.active: rest # or mcp

Sample MCP Configuration Code

{
  "mcpServers": {
    "[server-name]": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-[name]"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

📊 Performance & Compatibility Matrix

This section outlines the performance and compatibility matrix for typical use cases. The server is optimized to handle diverse interactions between AI applications, ensuring a smooth user experience.

🛠️ Advanced Configuration & Security

Detailed Configuration Settings

API Key Storage: Ensure API keys are stored securely through environment variables or vaults.
Security Protocols: Implement HTTPS for secure communication channels.
Rate Limiting: Configure rate limits to prevent server overload.

❓ Frequently Asked Questions (FAQ)

Integration with Other MCP Clients:
- The MemGPT Sample MCP Server is compatible with major clients like Claude Desktop and Continue, as detailed in the matrix.
Handling Complex Contextual Scenarios:
- Utilize core memory management for extensive conversation tracking to maintain context across multiple interactions.
Security Best Practices?
- Always use environment variables or secure vaults to protect API keys from unauthorized access.
Efficiency with Large-Dataset Archives:
- Implement efficient archiving and retrieval mechanisms to manage large datasets without impacting performance.
Customization Options for Advanced Users:
- Customize configurations via command-line arguments and environment variables to tailor the server to specific needs.

👨‍💻 Development & Contribution Guidelines

Contributing Instructions

Fork the repository from GitHub.

Clone the fork locally:

git clone https://github.com/your-forked-repo.git

Make changes and push them to your branch.
Submit a pull request.

🌐 MCP Ecosystem & Resources

Additional Resources

Explore our extensive documentation, developer forums, and community resources for more information on integrating the MemGPT Sample MCP Server into your projects:

MemGPT Sample