Mem0 MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, but there is some potential confusion between get_memories (filtered listing) and search_memories (semantic search), as both involve retrieving memories with filters. The descriptions clarify the difference, but an agent might initially struggle to choose between them. Other tools like add_memory, delete_memory, and update_memory are clearly differentiated.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern using snake_case, such as add_memory, delete_memory, and get_memories. This predictability makes it easy for agents to understand and use the tools without confusion about naming conventions.
Tool Count5/5
With 9 tools, this server is well-scoped for memory management, covering core operations like adding, retrieving, updating, deleting, and searching memories, as well as entity management. Each tool serves a clear purpose without redundancy, making the count appropriate for the domain.
Completeness5/5
The tool set provides comprehensive coverage for memory management, including CRUD operations (add, get, update, delete), bulk and entity-level deletions, listing entities, and both filtered and semantic search capabilities. There are no obvious gaps, allowing agents to handle full memory lifecycles effectively.
Average 3.5/5 across 9 of 9 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the destructive action ('Delete every memory') and clarifies that entities are preserved ('keep the entity'), which is useful. However, it lacks critical details: no mention of permissions required, irreversibility, confirmation prompts, rate limits, or what the output schema returns. For a high-impact deletion tool, this is insufficient.
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?
The description is a single, efficient sentence that front-loads the core action ('Delete every memory') and adds clarifying context ('but keep the entity'). There is zero waste or redundancy, making it highly concise and well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's high complexity (destructive bulk deletion) and lack of annotations, the description is incomplete. It covers the basic action and entity preservation but omits safety warnings, permissions, irreversibility, and output details. The presence of an output schema helps, but the description should do more to contextualize this risky operation.
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 description coverage is 100%, with each parameter well-documented in the schema (e.g., 'User scope to delete; defaults to server user'). The description adds no parameter-specific details beyond implying scoping ('in the given user/agent/app/run'), which the schema already covers. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete every memory') and the target resource ('in the given user/agent/app/run'), which is specific and actionable. It distinguishes from siblings like 'delete_memory' (singular) and 'delete_entities' (different resource). However, it doesn't explicitly contrast with all siblings (e.g., 'search_memories' for finding vs. deleting).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'delete_memory' (for single deletions) or 'delete_entities' (for different resources). It mentions keeping the entity, but doesn't clarify when bulk deletion is appropriate or warn against misuse. No explicit when/when-not instructions are included.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'overwrite' which implies a destructive mutation, but doesn't disclose behavioral traits like permission requirements, whether the operation is reversible, rate limits, or what happens to the old text. For a mutation tool with zero annotation coverage, this is a significant gap.
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?
The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse quickly.
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?
Given that there's an output schema (which covers return values), no annotations, and high schema coverage, the description is minimally adequate. However, as a mutation tool with no behavioral disclosure, it lacks completeness for safe and effective use by an AI agent.
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 description coverage is 100%, so the schema already documents both parameters ('memory_id' and 'text') thoroughly. The description adds no additional meaning beyond what the schema provides, such as format details or constraints, but doesn't need to compensate for gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Overwrite') and resource ('an existing memory's text'), making the purpose immediately understandable. It doesn't explicitly distinguish from siblings like 'add_memory' or 'delete_memory', but the verb 'overwrite' implies modification rather than creation or removal.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'add_memory' or 'delete_memory'. The description only states what it does without context about prerequisites, timing, or comparisons to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool lists entities holding memories but doesn't cover aspects like whether it's read-only, pagination, rate limits, or error handling. This leaves significant gaps for a tool that interacts with memory data.
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?
The description is a single, clear sentence that directly states the tool's function without any fluff. It's front-loaded and efficiently communicates the core purpose, making it highly concise and well-structured.
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?
Given the tool has 0 parameters and an output schema exists, the description's job is simplified. It adequately states what the tool does, but for a memory-related tool with no annotations, it could benefit from more context on behavior (e.g., read-only nature, data format). It meets the minimum for this complexity level but has room for improvement.
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?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't add parameter details, earning a high score for not introducing unnecessary information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and the resource ('users/agents/apps/runs currently hold memories'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'get_memories' or 'search_memories', which might also retrieve memory-related data, so it misses full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as 'get_memories' or 'search_memories'. It lacks context on use cases, exclusions, or prerequisites, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 of behavioral disclosure. It mentions the requirement for identifiers but lacks details on permissions, rate limits, whether the operation is idempotent, or what happens on success/failure. For a write operation with no annotation coverage, this leaves significant gaps in understanding the tool's behavior.
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?
The description is extremely concise with just two sentences that directly convey the core purpose and a key requirement. Every word serves a purpose, and it's front-loaded with the main action, making it efficient and easy to parse.
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?
Given the complexity of 8 parameters, no annotations, but with a rich input schema (100% coverage) and an output schema present, the description is minimally adequate. It covers the basic purpose and a critical requirement but doesn't address behavioral aspects like error handling or performance, leaving room for improvement despite the structured support.
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 description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by hinting at the identifier requirement but doesn't provide additional semantic context beyond what's in the schema, such as examples or edge cases. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Store') and resource type ('preference, fact, or conversation snippet'), making the purpose evident. It doesn't explicitly differentiate from sibling tools like 'update_memory' or 'get_memories', but the verb 'Store a new' implies creation rather than modification or retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some context by specifying that at least one identifier (user_id, agent_id, or run_id) is required, which implies usage when scoping a memory. However, it doesn't explicitly state when to use this tool versus alternatives like 'update_memory' for modifications or 'get_memories' for retrieval, leaving the guidelines somewhat implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions user confirmation requirement, which is valuable behavioral context. However, it lacks details on permissions needed, whether deletion is reversible, rate limits, or what happens upon success/failure. For a destructive operation with zero annotation coverage, this is insufficient.
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?
The description is a single, clear sentence that efficiently conveys the core action and key constraint (user confirmation). It's front-loaded with the main purpose and wastes no words.
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?
Given the tool has an output schema (not provided in details), the description doesn't need to explain return values. However, as a destructive operation with no annotations, it should provide more behavioral context about permissions, reversibility, or error handling. The description is adequate but has clear gaps for a deletion tool.
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 description coverage is 100%, with the parameter memory_id documented as 'Exact memory_id to delete.' The description adds minimal value by restating this parameter in context, but doesn't provide additional syntax, format examples, or constraints beyond what the schema already covers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and resource ('one memory'), specifying it operates on a single memory identified by memory_id. It distinguishes from siblings like delete_all_memories by focusing on single deletion, but doesn't explicitly contrast with other deletion tools like delete_entities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a user wants to delete a specific memory after confirmation, but doesn't provide explicit guidance on when to use this versus alternatives like delete_all_memories or delete_entities. No prerequisites or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 states 'Fetch a single memory', which implies a read-only operation, but doesn't disclose behavioral traits such as error handling (e.g., what happens if memory_id is invalid), authentication needs, rate limits, or response format. This leaves significant gaps for a tool with no annotation coverage.
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?
The description is a single, efficient sentence with zero waste. It front-loads the key information ('Fetch a single memory') and adds a concise usage note ('once you know its memory_id'), making it appropriately sized and well-structured.
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 the tool's simplicity (1 parameter, 100% schema coverage, and an output schema exists), the description is mostly complete. It clarifies the tool's purpose and basic usage. However, without annotations, it could benefit from more behavioral context, but the output schema reduces the need to explain return values, keeping it adequate.
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?
The schema description coverage is 100%, with the parameter 'memory_id' well-documented as 'Exact memory_id to fetch'. The description adds minimal value beyond this, only reinforcing that the memory_id must be known. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Fetch') and resource ('a single memory'), distinguishing it from sibling tools like 'get_memories' (plural) and 'search_memories'. However, it doesn't explicitly differentiate from 'list_entities' or 'delete_memory', which could also involve memory operations, leaving some ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by stating 'once you know its memory_id', suggesting it's for retrieving specific memories rather than listing or searching. However, it lacks explicit guidance on when to use this versus alternatives like 'get_memories' or 'search_memories', and doesn't mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and adds valuable behavioral context. It discloses that 'user_id is automatically added to filters if not provided' - an important implementation detail not evident from the schema. It also provides practical filter patterns showing how the tool behaves with different query structures. However, it doesn't mention rate limits, authentication requirements, or pagination behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately front-loaded with the core purpose, but the extensive filter examples (5 patterns) make it somewhat lengthy. While the examples are helpful, they could potentially be streamlined. Every sentence earns its place by providing practical guidance, but the structure could be more concise.
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 the tool's complexity (semantic search with filtering), no annotations, but with complete schema coverage and an output schema, the description provides good contextual coverage. It explains the core search behavior, provides practical filter examples, and discloses the automatic user_id injection. The presence of an output schema means the description doesn't need to explain return values. However, for a search tool with no annotations, it could benefit from mentioning performance characteristics or result ordering.
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?
With 100% schema description coverage, the baseline is 3. The description adds meaningful value by explaining filter usage patterns with concrete examples, showing how the 'filters' parameter works in practice. It also clarifies the automatic user_id injection behavior, which enhances understanding beyond the schema's technical description. However, it doesn't provide similar context for 'enable_graph' or 'limit' parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Run a semantic search over existing memories.' This specifies the verb ('search') and resource ('memories'), and the semantic aspect distinguishes it from simple filtering. However, it doesn't explicitly differentiate from sibling tools like 'get_memories' or 'list_entities'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage context through filter examples and the note about automatic user_id injection, suggesting this is for retrieving memories with semantic matching. However, it lacks explicit guidance on when to use this tool versus alternatives like 'get_memories' (which appears to be a simpler retrieval) or 'list_entities'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It effectively discloses key behavioral traits: the tool performs a destructive operation ('Remove entirely'), specifies what gets deleted (entities and their memories via cascade), and identifies the types of entities affected. However, it lacks details on permissions, rate limits, or error conditions.
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?
The description is a single, efficient sentence that front-loads the core action and scope. Every word earns its place by specifying the verb, resources, and cascade effect without redundancy or unnecessary elaboration.
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 the tool's destructive nature, no annotations, and an output schema (which handles return values), the description is reasonably complete. It covers the purpose, scope, and cascade behavior, though it could benefit from more explicit warnings about irreversibility or usage guidelines relative to siblings.
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 description coverage is 100%, with each parameter documented in the schema. The description adds value by clarifying that parameters are mutually exclusive (implied by 'a user/agent/app/run record' singular) and that deletion cascades to memories, but does not provide additional syntax or format details 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 the specific action ('Remove entirely') and identifies the target resources ('user/agent/app/run record'), distinguishing it from sibling tools like delete_memory or delete_all_memories. It also specifies the cascade effect on memories, which adds important context about the scope of deletion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for permanent removal of entities with memory cascading, but does not explicitly state when to use this versus alternatives like delete_memory (for individual memories) or delete_all_memories (for all memories without entity deletion). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: pagination mechanics (page and page_size), automatic user_id injection into filters, and the default page_size of 10. However, it doesn't mention rate limits, authentication requirements, or error conditions, leaving some gaps.
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?
The description is well-structured and front-loaded with the core purpose, followed by usage guidelines and parameter semantics. Every sentence earns its place by providing essential information without redundancy, making it efficient and easy to parse.
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 the tool's moderate complexity (4 parameters, no annotations, but with an output schema), the description is largely complete. It covers purpose, usage, key behaviors, and parameter details. The presence of an output schema means return values don't need explanation, but minor gaps remain in behavioral aspects like error handling or advanced usage notes.
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 description coverage is 100%, so the baseline is 3. The description adds significant value by explaining the 'filters' parameter with concrete examples (e.g., single user, agent memories), clarifying that 'user_id is automatically added,' and noting pagination details. This enhances understanding beyond the schema's technical definitions.
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 tool's purpose as 'Page through memories using filters instead of search,' which is a specific verb+resource+method combination. It distinguishes from sibling tools like 'search_memories' by emphasizing the filter-based approach versus search functionality.
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?
The description provides explicit guidance on when to use this tool ('use filters to list specific memories') and implicitly contrasts it with 'search_memories' by stating 'instead of search.' It also offers common filter patterns as practical examples, helping the agent understand appropriate use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mem0_mcp_private MCP server](https://glama.ai/mcp/servers/parthshr370/mem0_mcp_private/badges/card.svg)](https://glama.ai/mcp/servers/parthshr370/mem0_mcp_private)

Score Badge

Copy to your README.md:

[![mem0_mcp_private MCP server](https://glama.ai/mcp/servers/parthshr370/mem0_mcp_private/badges/score.svg)](https://glama.ai/mcp/servers/parthshr370/mem0_mcp_private)

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/parthshr370/mem0_mcp_private'

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