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: karve

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

Available Tools

6 tools

add_memoryA

Save important information to long-term memory.

When to Use

User stated preferences ('User prefers dark mode')
Personal context ('User is learning Rust', 'User works on payments team')
Project patterns ('API endpoint at /api/v2', 'Uses PostgreSQL for this project')
Agreed decisions ('Team decided to use Docker for deployment')
Constraints ('Budget is tight', 'Deadline is end of month')
Lessons learned ('Don't use library X, it caused issues')

Post-Response Storage Pattern (IMPORTANT)

After responding to user, EVALUATE whether new facts should be stored:

Did user share personal context? → Store it
Did we make a technical decision? → Store it
Did user express a preference? → Store it
Did user correct previous information? → Update existing memory

Deduplication

Search before adding if the info seems routine. Prefer UPDATING existing memories when finding conflicting info. Store each distinct piece as a separate memory with clear, searchable text.

ParametersJSON Schema

Name	Required	Description
`text`	Yes	Memory content - write clear, searchable statement (e.g., 'User prefers dark mode theme').
`user_id`	No	User identifier (optional, uses default if not set).
`agent_id`	No	Session/run identifier for grouping related memories.
`metadata`	No	Additional metadata (runId supported).

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, but the description discloses deduplication behavior ('Search before adding', 'Prefer UPDATING existing memories') and storage pattern. Does not mention return value or side effects, but acceptable for a simple store tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well-structured with headings and bullet points, front-loaded with purpose. Slightly long but every sentence adds value. Could be shorter, but not verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers usage scenarios, deduplication, storage pattern, and parameter guidance. No missing information given the tool's simplicity and lack of output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with all parameters described. The description adds value for the 'text' parameter by advising to write 'clear, searchable statements'. No additional detail for other params beyond schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Save important information to long-term memory' and provides specific examples of what to store (preferences, context, decisions). It distinguishes from siblings like search_memories, update_memory, and delete_memory.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The 'When to Use' section explicitly lists categories of information (preferences, personal context, project patterns). The 'Post-Response Storage Pattern' gives procedural guidance. Missing explicit when-not-to-use, but adequate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

delete_all_memoriesA

Bulk delete all memories for a user, optionally filtered to a specific session.

Use Cases

User starts fresh on a project ('Clear all my memories')
Complete privacy wipe requested
Abandoned/debug session cleanup
User explicitly requests full memory reset

Caution

Destructive and irreversible. Confirm with user if request seems broad.

Without agent_id: deletes ALL user memories With agent_id: deletes only that session's memories

Pre-Deletion Recommendation

Before bulk delete, consider:

Informing user how many memories will be deleted
Confirming they want to proceed
Suggesting targeted delete if they only want to remove specific memories

ParametersJSON Schema

Name	Required	Description	Default
`user_id`	No	User identifier (optional, uses default if not set).
`agent_id`	No	Optional: delete only memories from this specific session/run.

TDQS

A4.6/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. Clearly states destructive and irreversible nature, and behavior difference with/without agent_id. Pre-deletion recommendation adds context. Lacks mention of return value or side effects, but for a delete tool this is sufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is moderately verbose with bullet points and sections, but each part earns its place (use cases, caution, pre-deletion recommendations). Could be trimmed slightly, but front-loaded first sentence conveys core purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and two optional parameters, description covers use cases, caution, and parameter behavior. Lacks detail on return value or default user_id, but sufficient for a destructive bulk operation. Siblings are well-differentiated.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage 100%, but description adds significant value: explains how agent_id filters to a session, and implies user_id defaults. Clarifies behavior beyond schema descriptions, enabling correct tool usage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states 'Bulk delete all memories for a user, optionally filtered to a specific session.' The verb 'bulk delete' and resource 'memories' are specific. Differentiates from sibling 'delete_memory' which deletes a single memory.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit use cases listed (fresh start, privacy wipe, cleanup, memory reset). Caution warns of destructiveness and irreversibility, advising confirmation. Recommends targeted delete as alternative, distinguishing from delete_memory.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

delete_memoryA

Remove a specific memory when it is no longer relevant, was stored in error, or user requests deletion.

When to Use

User requests deletion ('Forget what I said about X')
Old version redundant after update
Something stored by mistake
User explicitly asks to 'forget' or 'delete' specific information

Privacy

Honor all deletion requests promptly. User privacy is paramount.

Cleanup Pattern

After post-response storage evaluation, if a memory is found to be:

Redundant with newly updated version
Incorrectly stored
No longer relevant

→ Delete the old/incorrect memory to maintain clean memory store.

ParametersJSON Schema

Name	Required	Description	Default
`id`	Yes	Memory ID to delete.

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It covers privacy and cleanup patterns but does not mention irreversibility, authentication, or side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well-structured with clear headings. Front-loaded with purpose, then guidelines, privacy, and cleanup. Each section adds value, though could be slightly more concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers main use cases but lacks explanation of return values or error handling (e.g., invalid id). Adequate for a simple deletion tool but incomplete for edge cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Only one parameter 'id' with schema description already clear. The description adds no extra meaning beyond schema, and coverage is 100%.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Remove' and the resource 'specific memory', distinguishing it from siblings like delete_all_memories. It also specifies contexts where deletion is appropriate.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The 'When to Use' section provides specific scenarios such as user requests deletion, redundancy, or error. It implicitly excludes other operations but does not explicitly name alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_memoryA

Retrieve a specific memory by its ID.

When to Use

You have a memory ID from a previous search result
After adding a memory and need to verify or get full details
User asks for details about a specific memory they referenced
After update/delete operations to confirm results

Pre-Execution Recall

Usually you'll use search_memories first to find relevant memories. Use get_memory when you already have an ID and need full details.

Returns full memory details including metadata, timestamps, and the stored content.

ParametersJSON Schema

Name	Required	Description	Default
`id`	Yes	The memory ID to retrieve.

TDQS

A4.1/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It states the return includes 'full memory details including metadata, timestamps, and the stored content' but does not mention error handling (e.g., if ID not found) or other behavioral traits like idempotency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is well-structured with clear sections, concise (about 5 sentences), and every sentence adds value with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple retrieval tool with 1 parameter and no output schema, the description provides enough context: when to use, what it returns, and relationship to siblings. Complete for the complexity level.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has 1 parameter 'id' with description 'The memory ID to retrieve.' Schema coverage is 100%. Description does not add new parameter info beyond schema; baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states 'Retrieve a specific memory by its ID.' It specifies the verb (retrieve) and resource (memory by ID), and distinguishes from sibling tools like search_memories.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit 'When to Use' and 'Pre-Execution Recall' sections, explaining when to use this tool (e.g., have memory ID) and recommending search_memories when lacking an ID. Lacks explicit when-not-to-use but context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_memoriesA

Query stored memories to retrieve relevant context.

Pre-Execution Recall Pattern (IMPORTANT)

BEFORE responding to user, search for relevant memories based on context:

User asks about skills/capabilities? → Search 'user programming language', 'user technical skills'
User mentions location/environment? → Search 'user city', 'user location', 'user timezone'
User asks about preferences? → Search 'user preference', 'user coding preference'
User references past decisions? → Search 'user decision', 'user project choice'
User asks about project context? → Search 'user project framework', 'user project database'

Triggers

When starting new tasks (check 'has user worked on this before?')
Before giving advice on topics from past sessions
When user references something you don't recall
After any significant decision or preference is stated

Proactive Early Search

At session start, consider searching 'user preferences', 'project architecture', 'agreed approach' to build context.

Use lower limits (1-3) for specific lookups, higher limits (5-10) for broad context.

ParametersJSON Schema

Name	Required	Description
`query`	Yes	Natural language search query (e.g., 'user coding preferences', 'database setup decisions').
`user_id`	No	User identifier to scope search to specific user.
`agent_id`	No	Optional session filter to find memories from current run.
`limit`	No	Max results (default: 5, increase for broader context).

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It describes retrieval behavior but does not disclose side effects, permissions, or safety profile. It is adequate but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is overly verbose with extensive bullet points and patterns. While informative, it could be more concise and front-loaded. Many details could be streamlined.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema exists, so description should explain return values but does not. It covers usage patterns well but lacks information on result format. Adequate but not fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description adds practical advice like 'lower limits (1-3) for specific lookups, higher limits (5-10) for broad context' and mentions the default limit, adding value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Query stored memories to retrieve relevant context' using a specific verb and resource. It distinguishes itself from sibling tools like add_memory, delete_memory, etc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides extensive guidelines including triggers, pre-execution recall patterns, proactive search, and limit recommendations. It does not explicitly exclude when not to use, but gives clear usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

update_memoryA

Update an existing memory when information changes or needs correction.

When to Use

Same fact changes ('User now prefers light mode instead of dark')
More precise info becomes available ('Project uses PostgreSQL 16, not 15')
User corrects previous information
Correcting errors in stored facts

Post-Response Correction Pattern

After responding, if user provides CORRECTIONS or UPDATED information:

Search for existing memory on the topic
If found → UPDATE the existing memory
If not found → ADD new memory (don't force update on genuinely new topics)

Storage Decision

ADD NEW for genuinely new topics
UPDATE existing when same fact changes
If unsure, prefer ADD - storing multiple perspectives is safer than losing context

The text field replaces content entirely; metadata (runId) preserves linkage.

ParametersJSON Schema

Name	Required	Description
`id`	Yes	Memory ID to update (from get_memory or search results).
`text`	No	Updated memory content - replaces previous text entirely.
`metadata`	No	Metadata updates (only runId supported for linkage to new sessions).

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It explains that text replaces content entirely, metadata preserves linkage, and discusses update vs add decision. Lacks details on permissions or failure modes, but adequate for the context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well-structured with sections, front-loaded purpose. Slightly verbose but each section is informative. No wasted sentences.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, description covers usage scenarios, storage decisions, and parameter behavior. Lacks return value details but sufficient for a simple update tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, baseline 3. Description adds value by explaining that text replaces previous content entirely and metadata only supports runId, and that id is from get_memory or search results.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states 'Update an existing memory when information changes or needs correction.' Uses specific verb+resource, and differentiates from siblings like add_memory and delete_memory.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit when-to-use scenarios: same fact changes, more precise info, user corrections, correcting errors. Also includes post-response correction pattern and storage decision for clarification.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

6 tool updatesv0.2.0May 25, 2026
- First observedadd_memory
- First observeddelete_all_memories
- First observeddelete_memory
- First observedget_memory
- First observedsearch_memories
- First observedupdate_memory

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.3/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: add, delete individual, bulk delete, get by ID, search, and update. There is no overlap or confusion between them.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case, e.g., add_memory, delete_all_memories, delete_memory, get_memory, search_memories, update_memory. The pattern is predictable and clear.

Tool Count5/5

With 6 tools, the server is well-scoped for memory management. Each tool earns its place, covering essential operations without unnecessary bloat or sparseness.

Completeness5/5

The tool surface covers all fundamental memory operations: create, read, update, delete (individual and bulk), and search. There are no obvious gaps for typical memory management tasks.

Maintenance

ActivityInactive

ResponsivenessNo issues

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.

Related MCP Connectors

nexsusOAuth
io.github.dbnexsus
Private persistent memory for Claude, ChatGPT & Gemini via MCP - semantic search, zero-code setup.
Knowledge & Memory RAG Systems
2
MemoryRouter A
ai.memoryrouter
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Knowledge & Memory Search
101
mifactory-agent-memory C
io.github.mifactory-bot
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
Knowledge & Memory Autonomous Agents Agent Orchestration
22
mcpOAuth
ai.butlerbrain
Persistent memory for AI assistants. Save once; recall from Claude, ChatGPT, or any MCP client.
Knowledge & Memory RAG Systems Workplace & Productivity
2

Related MCP Servers

MCP Qdrant Semantic Search
Vector Databases Knowledge & Memory
muhammedehab35
A
license
Not graded
quality
D
maintenance
Enables Claude to store and retrieve information with semantic search using Qdrant vector database, providing persistent memory for conversations, code, and documentation.
Updated 8 months ago (2026-01-18 03:52 UTC)
9
MIT
karve
Knowledge & Memory RAG Systems AI & Machine Learning
cspenn
F
license
Not graded
quality
D
maintenance
Provides persistent semantic memory for Claude Code via local embeddings and six MCP tools, enabling context storage and retrieval across sessions without cloud dependencies.
Updated 6 months ago (2026-03-20 00:47 UTC)
-
semantic-memory
Knowledge & Memory RAG Systems
GFYURI
A
license
Not graded
quality
C
maintenance
Persistent memory with semantic search for Claude and MCP-compatible clients, storing context that survives conversations and can be retrieved intelligently.
Updated 10 months ago (2025-10-29 03:59 UTC)
1
MIT
cc-history
Knowledge & Memory Search
Straska7
A
license
Not graded
quality
C
maintenance
Provides local-first, cross-session memory for Claude Code, enabling semantic search across past sessions to retrieve procedures, decisions, or answers without exposing secrets.
Updated 2 months ago (2026-07-04 22:43 UTC)
Apache 2.0

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
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

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

RememberMe - CLI + MCP Server

Table of Contents

Features

Quick Start

Installation

Prerequisites

Step 1: Clone the Repository

Step 2: Install Dependencies

Step 3: Configure Environment

Step 4: Start Qdrant

Step 5: Verify Installation

Step 6: Try Your First Command

Troubleshooting

CLI Commands

CLI Options

Architecture

MCP Server Integration

Method 1: Using claude code command

Method 2: Manual configuration (persistent)

Available MCP Tools

OpenClaw Skill Integration

Configuration

Environment Variables

Data Format

Project Structure

Run Tests

License

Available Tools

When to Use

Post-Response Storage Pattern (IMPORTANT)

Deduplication

Use Cases

Caution

Pre-Deletion Recommendation

When to Use

Privacy

Cleanup Pattern

When to Use

Pre-Execution Recall

Pre-Execution Recall Pattern (IMPORTANT)

Triggers

Proactive Early Search

When to Use

Post-Response Correction Pattern

Storage Decision

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API