Agentwong Optimized Memory MCP Server

🚀 Optimized Memory MCP Server

This project is designed to test and demonstrate Claude AI's programming capabilities, as well as a good AI workflow and prompt design. It is a memory MCP server based on Python (I believe the official version is written in Java) and uses SQLite as the backend.

🚀 Quick Start

This is a memory MCP server that implements basic memory functions through a local knowledge graph for persistent memory. This enables Claude to remember user information across different chat records.

✨ Features

Core Concepts

Entities

Entities are the main nodes in the knowledge graph. Each entity has:

• A unique name (identifier)
• An entity type (e.g., "person", "organization", "event")
• A list of observations

Example:

{
  "name": "John_Smith",
  "entityType": "person",
  "observations": ["Speaks fluent Spanish"]
}

Relationships

Relationships define the directional connections between entities. They are always stored in the active voice and describe how entities interact or relate to each other.

Example:

{
  "from": "John_Smith",
  "to": "Anthropic",
  "relationType": "works_at"
}

Observations

Observations are discrete pieces of information about entities. They are:

• Stored as strings
• Attached to specific entities
• Can be added or removed independently
• Should be atomic facts

📚 Documentation

API Tool Instructions

Create Entities

Function: Create a new entity. Input Parameters:

• name (string): The name of the entity.
• entityType (string): The entity type, such as "person", "organization", etc.

Example Code:

response = client.create_entities([
    {"name": "John_Doe", "entityType": "person"},
    {"name": "TechCorp", "entityType": "organization"}
])

Update Entity

Function: Update the attributes of an existing entity. Input Parameters:

• name (string): The name of the entity.
• properties (dictionary): The attributes and values to be updated.

Example Code:

response = client.update_entity("John_Doe", {"age": 30, "location": "New York"})

Get Entity

Function: Retrieve information about a specific entity. Input Parameters:

• name (string): The name of the entity.

Example Code:

response = client.get_entity("John_Doe")
print(response)  # Output the detailed information of the entity

Delete Entity

Function: Delete a specific entity. Input Parameters:

• name (string): The name of the entity.

Example Code:

client.delete_entity("John_Doe")  # Returns True if deletion is successful, False otherwise

Integration with Claude Desktop

Prompt Design

When using the memory function, prompt design is crucial. Adjusting the prompt can help the model decide the frequency and type of memory.

Example Prompt:

Follow these steps for each interaction:

1. User Identification:
   - Assume you are interacting with default_user.
   - If default_user has not been identified, actively try to identify them.

2. Memory Retrieval:
   - Always start with "Remembering..." and retrieve all relevant information from the knowledge graph.
   - Refer to the knowledge graph as your "memory".

3. Memory Management:
   - When communicating with the user, pay attention to any new information, including the following categories:
     a) Basic interpersonal relationships (age, gender, location, position, education level, etc.)
     b) Behaviors (interests, habits, etc.)
     c) Preferences (communication style, preferred language, etc.)
     d) Goals (objectives, targets, aspirations, etc.)
     e) Relationships (personal and professional relationships, up to three levels)

4. Memory Update:
   - If new information is collected during the interaction, update the memory as follows:
     a) Create entities for recurring organizations, people, and important events.
     b) Connect them to the current entity using relationships.
     c) Store facts about them as observations.

💻 Usage Examples

Basic Usage

Initialization:

client = MCPClient()  # Initialize the MCP client

# Create user entities
response = client.create_entities([
    {"name": "User_123", "entityType": "person"},
    {"name": "Default_Project", "entityType": "project"}
])

# Update user attributes and relationships
client.update_entity("User_123", {
    "age": 28,
    "location": "Shanghai",
    "preferences": ["Technical communication", "Learning"]
})

# Add observations
client.add_observations("User_123", [
    {"content": "The user showed interest in artificial intelligence in the project", "timestamp": "2023-10-05"},
    {"content": "The user prefers to have technical discussions in the morning", "timestamp": "2023-10-06"}
])

# Retrieve memory
memory = client.get_entity("User_123")
print(memory)  # Output the user's detailed information and associated relationships

# Delete entities (clean up)
client.delete_entity("Default_Project")  # Returns True if successful, False otherwise

📦 Installation

Docker Build

docker build -t mcp/memory -f src/memory/Dockerfile . 

📄 License

This MCP server is released under the MIT License. This means you are free to use, modify, and distribute the software, but you must comply with the terms and conditions of the MIT License. For more details, please refer to the LICENSE file in the project repository.