Which integrations are available for this server?

Integrates with OpenAI-compatible embedding APIs to automatically vectorize memory content for semantic search.

How do I use RememberMe?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@RememberMe remember that I prefer dark mode" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

RememberMe

by JoeXie

Overview Schema Related Servers Score Discussions

Python

Local

RememberMe - CLI + MCP Server

A dual-mode tool providing long-term memory management for Claude Code and other MCP clients. Features both a CLI interface for direct commands and an MCP server for programmatic access.

Built on Qdrant vector database with semantic search and user/session isolation.

Related MCP server: MCP Qdrant Semantic Search

Features

Dual-Mode: CLI commands + MCP server integration
Semantic Search - Natural language queries using vector similarity
Multi-User Support - User memory isolation via userId
Session Tracking - Associate memories with specific agent sessions via runId
Content Deduplication - MD5 hash to detect duplicate memories
Auto-Vectorization - OpenAI-compatible embedding service integration

Quick Start

# Install
pip install -e .

# CLI usage
rememberme add "User prefers dark mode"
rememberme search "preferences" --limit 5
rememberme status

# MCP mode (for Claude Code)
python -m rememberme

Installation

This guide walks you through setting up RememberMe from downloading the repository to your first command.

Prerequisites

Python 3.10+
Qdrant (vector database) - Install via Docker
Embedding API (OpenAI-compatible) - e.g., Doubao, OpenAI, LocalAI

Step 1: Clone the Repository

git clone https://github.com/JoeXie/remember-me.git
cd remember-me

Or download and extract the archive from GitHub.

Step 2: Install Dependencies

pip install -e .

This installs RememberMe in development mode and creates the rememberme command.

Step 3: Configure Environment

Create the config directory and copy the example env file:

mkdir -p ~/.config/rememberme/
cp .env.example ~/.config/rememberme/.env

Edit ~/.config/rememberme/.env with your settings:

# Required: Your embedding API credentials
EMBEDDING_API_KEY=your_api_key_here
OPENAI_BASE_URL=https://ark.cn-beijing.volces.com/api/coding/v3

# Required: Embedding model configuration
EMBEDDING_MODEL=doubao-embedding-vision
EMBEDDING_DIMENSIONS=2048

# Optional: Qdrant connection (defaults shown)
QDRANT_HOST=localhost
QDRANT_PORT=6333
QDRANT_COLLECTION_NAME=memories

# Optional: Default user ID
DEFAULT_USER_ID=user_default

Step 4: Start Qdrant

Make sure Qdrant is running:

# Using Docker
docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant

# Or using Podman
podman run -p 6333:6333 -p 6334:6334 qdrant/qdrant

Step 5: Verify Installation

Check that everything is connected:

rememberme status

Expected output:

## RememberMe Status

- **Qdrant**: `Connected`
  - Host: `localhost:6333`
  - Collection: `memories`
- **Memories**: `0` stored

Step 6: Try Your First Command

# Add a memory
rememberme add "User prefers dark mode theme"

# Search memories
rememberme search "preferences"

# Get help
rememberme --help

Troubleshooting

Issue	Solution
`QdrantOfflineError`	Ensure Qdrant is running (`docker run -p 6333:6333 qdrant/qdrant`)
`ValidationError`	Check `EMBEDDING_API_KEY` and `OPENAI_BASE_URL` in `~/.config/rememberme/.env`
Command not found	Re-run `pip install -e .` to create the `rememberme` command
Collection error	RememberMe auto-creates the collection on first run
Config not found	Ensure `~/.config/rememberme/.env` exists (or will be auto-created)

CLI Commands

# Add a new memory
rememberme add "User prefers dark mode"

# Search memories
rememberme search "user preferences"
rememberme search "project decisions" --limit 10

# Check status
rememberme status

# Delete a memory
rememberme delete <memory_id>

# Delete all memories
rememberme delete-all --force

# JSON output (for programmatic use)
rememberme add "text" --json
rememberme search "query" --json

CLI Options

Option	Description
`--user-id`	User ID scope (defaults to DEFAULT_USER_ID env var)
`--debug`	Enable debug logging

Architecture

                    Dual-Mode Entry
                  ┌─────────────────┐
                  │  __main__.py    │
                  │  auto-detects   │
                  └────────┬────────┘
                           │
          ┌────────────────┼────────────────┐
          │                                 │
          ▼                                 ▼
    ┌───────────┐                    ┌─────────────┐
    │  CLI Mode │                    │ MCP Mode    │
    │  (Click)  │                    │ (stdio)     │
    └─────┬─────┘                    └──────┬──────┘
          │                                 │
          ▼                                 │
    MemoryManager                           │
    (core/memory_manager.py)                │
          │                                 │
          └────────────────┼────────────────┘
                           │
                           ▼
              ┌─────────────────────────┐
              │     MemoryStore         │
              │   (Qdrant operations)   │
              └─────────────────────────┘

MCP Server Integration

Method 1: Using claude code command

# Add MCP server
claude mcp add rememberme -- python -m rememberme

# Or specify working directory
claude mcp add rememberme -- bash -c "cd /path/to/RememberMe && python -m rememberme"

Method 2: Manual configuration (persistent)

Add to ~/.claude/settings.json:

{
  "mcpServers": {
    "rememberme": {
      "command": "python",
      "args": ["-m", "rememberme"],
      "env": {
        "QDRANT_HOST": "<HOST>",
        "QDRANT_PORT": "<PORT>",
        "EMBEDDING_API_KEY": "<YOUR_API_KEY>",
        "EMBEDDING_MODEL": "<EMBEDDING_MODEL>",
        "EMBEDDING_DIMENSIONS": "<EMBEDDING_DIMENSIONS>",
        "OPENAI_BASE_URL": "<OPENAI_BASE_URL>",
        "DEFAULT_USER_ID": "<DEFAULT_USER_ID>"
      }
    }
  }
}

Available MCP Tools

add_memory - Add a memory
search_memories - Semantic search
get_memory - Get a single memory
update_memory - Update a memory
delete_memory - Delete a memory
delete_all_memories - Clear all memories

OpenClaw Skill Integration

For OpenClaw agents, install the RememberMe skill to enable auto-recall and auto-storage:

# Install skill from local repository
/skill install path/to/RememberMe/skills/using-rememberme-cli --always true

Important: When installing, set always: true to enable automatic pre-execution recall and post-response storage on every conversation.

The skill provides:

Auto-Recall: Automatically searches memory before responding based on context
Auto-Storage: Evaluates and stores new facts after responding

Configuration

Configuration is loaded from ~/.config/rememberme/.env by default.

If this file doesn't exist, it will be created automatically (the directory will be created if needed).

To set up:

mkdir -p ~/.config/rememberme/
cp .env.example ~/.config/rememberme/.env

Then edit ~/.config/rememberme/.env with your settings.

Note: Environment variables (e.g., when running via MCP with env in ~/.claude/settings.json) take precedence over the .env file.

Environment Variables

Variable	Description	Default
`QDRANT_HOST`	Qdrant server address	`localhost`
`QDRANT_PORT`	Qdrant port	`6333`
`QDRANT_COLLECTION_NAME`	Collection name	`memories`
`QDRANT_API_KEY`	Qdrant API key	-
`EMBEDDING_API_KEY`	Embedding API key	Required
`EMBEDDING_MODEL`	Embedding model (OpenAI compatible)	`doubao-embedding-vision`
`EMBEDDING_DIMENSIONS`	Vector dimensions	`2048`
`OPENAI_BASE_URL`	Embedding API endpoint	Required
`DEFAULT_USER_ID`	Default user ID	`user_default`
`LOG_LEVEL`	Log level	`INFO`

Data Format

Payload structure stored in Qdrant:

{
  "userId": "<USER_ID>",
  "data": "Memory content",
  "hash": "<MD5_HASH>",
  "createdAt": "<TIMESTAMP>",
  "runId": "agent:main:<UUID>"
}

Project Structure

src/rememberme/
├── __main__.py          # Dual-mode entry (CLI + MCP auto-detect)
├── config.py            # Configuration management
├── models.py            # Data models
├── embeddings.py        # Embedding service
├── memory_store.py      # Qdrant operations
│
├── core/                # Core business logic
│   ├── __init__.py
│   ├── exceptions.py    # Custom exceptions
│   └── memory_manager.py
│
├── cli/                 # CLI interface
│   ├── __init__.py
│   ├── commands.py      # Click commands
│   ├── formatter.py    # Output formatters
│   └── lazy.py          # Lazy imports
│
├── mcp/                 # MCP adapter
│   ├── __init__.py
│   └── adapter.py       # MCP server
│
└── skill/               # OpenClaw skill
    └── manage_personal_memory.py

skills/                   # OpenClaw skills (distributed separately)
└── using-rememberme-cli/
    └── SKILL.md

tests/
├── test_models.py
├── test_config.py
└── test_embeddings.py

Run Tests

pytest tests/

License

MIT

Install Server

license - not found

quality

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Tools

Latest Blog Posts

Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly
Lightport: Open-Sourcing Glama's AI Gateway
By punkpeye on April 27, 2026.
OpenAI
open source

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/JoeXie/remember-me'

If you have feedback or need assistance with the MCP directory API, please join our Discord server