Getting Started

YoMemo provides a secure, encrypted memory layer for your AI applications. The easiest way to get started is using the Python MCP integration, which enables AI assistants like Claude and Cursor to save and retrieve encrypted memories seamlessly.

Why YoMemo?

End-to-End Encryption

All memories are encrypted client-side using RSA-OAEP and AES-GCM. The server never sees your plaintext data.

AI Assistant Ready

Built-in MCP server works out-of-the-box with Claude Desktop, Cursor, and other MCP-compatible tools.

Easy Integration

Get started in minutes with just a few configuration steps. No complex setup required.

User-Controlled Keys

You manage your own encryption keys. The server cannot decrypt your data.

Quick Start with Python MCP

The Python MCP integration is the recommended way to get started, especially if you’re using AI assistants like Claude Desktop or Cursor. See it in action: Cursor MCP in 50 Seconds (video + steps).

1. Install the MCP Server

   Use uvx to run the MCP server directly (no installation needed):

   uvx yomemoai-mcp --help

   Or install via pip:

   pip install yomemoai-mcp

   Tip

   uvx is recommended as it automatically handles dependencies and doesn’t require a global installation.

2. Get Your API Key

   Sign up at YoMemoAI to get your API key. You’ll need this to authenticate with the service.

   Caution

   Keep your API key secure and never commit it to version control. Use environment variables or secure configuration files.

3. Generate Your RSA Key Pair and Register Your Public Key

   You need an RSA key pair: the private key stays on your machine for decryption; the public key must be registered with YoMemo so the server can verify your encrypted data. We recommend creating keys locally (zero-trust); you can also generate them in the dashboard for a quick try.

   See the dedicated guide: Key Pairs (Public & Private) — it covers both options (online vs. local), how to upload your public key if you generate locally, and security notes.

4. Configure Your MCP Client

   Add the MCP server configuration to your AI assistant. The configuration location depends on your tool:

   For Cursor

   Edit ~/.cursor/mcp.json (or %APPDATA%\Cursor\User\mcp.json on Windows):

   {
     "mcpServers": {
       "yomemoai": {
         "command": "uvx",
         "args": ["yomemoai-mcp"],
         "env": {
           "MEMO_API_KEY": "your_api_key_here",
           "MEMO_PRIVATE_KEY_PATH": "/absolute/path/to/private.pem",
           "MEMO_BASE_URL": "https://api.yomemo.ai"
         }
       }
     }
   }

   For Claude Desktop

   Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

   {
     "mcpServers": {
       "yomemoai": {
         "command": "uvx",
         "args": ["yomemoai-mcp"],
         "env": {
           "MEMO_API_KEY": "your_api_key_here",
           "MEMO_PRIVATE_KEY_PATH": "/absolute/path/to/private.pem",
           "MEMO_BASE_URL": "https://api.yomemo.ai"
         }
       }
     }
   }

   Note

   Replace /absolute/path/to/private.pem with the absolute path to your private key file. On Windows, use forward slashes (e.g., C:/Users/YourName/private.pem).

5. Restart Your AI Assistant

   After saving the configuration, restart Cursor or Claude Desktop for the changes to take effect.

6. Start Using YoMemo

   Once configured, you can use YoMemo in your AI assistant conversations:

   Save a memory:

   "Please remember that my coffee machine password is 8888, with handle 'passwords'"

   Retrieve memories:

   "Can you recall my passwords?"

   Organize with handles:

   "Remember this project detail with handle 'project-alpha'"

How It Works

When you ask your AI assistant to save a memory:

1. Encryption: The MCP server encrypts your content using your local private key (AES-GCM + RSA-OAEP)
2. Signing: The encrypted data is signed for integrity verification
3. Storage: Only the encrypted ciphertext is sent to the YoMemo server
4. Privacy: The server cannot decrypt your data - it only stores encrypted content and your public key

When you ask your AI assistant to recall a memory:

1. Retrieval: The MCP server fetches encrypted data from YoMemo
2. Decryption: Your content is decrypted locally using your private key
3. Delivery: The plaintext is returned to your AI assistant

Tip

The entire encryption/decryption process happens on your local machine. The YoMemo server never sees your plaintext data.

Available MCP Tools

save_memory

Store important information, user preferences, or conversation context. When you use the same idempotent_key with the same handle, the existing memory is updated (upsert) instead of creating a duplicate.

Parameters:

• content (required): The information to be remembered
• handle (optional): A category or tag (e.g., ‘work’, ‘personal’, ‘project-x’). Defaults to ‘general’
• description (optional): A brief summary
• idempotent_key (optional): A stable key for upsert. If a memory with the same (handle, idempotent_key) already exists, it is updated; otherwise a new memory is created. Use for project progress, habit tracking, or avoiding duplicate memories.

load_memories

Retrieve previously stored memories.

Parameters:

• handle (optional): Filter by category. If not specified, returns all memories

Other Integration Options

While Python MCP is the easiest way to get started, YoMemo also supports other integration methods:

• Official Client: Free desktop and mobile app (Windows, macOS, iOS, Android) with the same encryption as MCP—manage memories in a GUI with a local lock.
• Go SDK: For programmatic access in Go applications
• REST API: Direct HTTP API access for any language

Security Best Practices

• ✅ Keep your private key secure: Store it with file permissions 600 (read/write for owner only)
• ✅ Never commit secrets: Add .env files and private keys to .gitignore
• ✅ Use environment variables: Store API keys in environment variables, not in code
• ✅ Backup your private key: If you lose it, you cannot recover your encrypted data
• ✅ Use strong keys: Generate 2048-bit or 4096-bit RSA keys

Troubleshooting

MCP Server Not Starting

1. Verify your MEMO_API_KEY is correct

2. Check that the private key path is absolute and the file exists

3. Ensure the private key file has correct permissions (recommended: 600)

4. Test locally to see error messages:

   MEMO_API_KEY="your_api_key" \
   MEMO_PRIVATE_KEY_PATH="/path/to/private.pem" \
   uvx yomemoai-mcp

Connection Issues

• Verify MEMO_BASE_URL is correct (default: https://api.yomemo.ai)
• Check your internet connection
• Ensure your API key is valid

Next Steps

• Learn more about Python MCP Integration for detailed configuration
• Explore How It Works to understand the encryption architecture
• Check out Go SDK Integration for programmatic access
• Read the API Reference for direct API access